conn_weight=an_t_weight, normalised_space=pop_size, get_max_dist=True, delay=0.1) an_t_list = [[] for _ in range(n_tds)] for (pre, post, w, d) in an_t_master: i = np.remainder(post, n_tds) an_t_list[i].append((pre, int((float(post) / n_t) * n_sub_t + 0.5), w, d)) # an_t_list = connection_dicts[0]['an_t_list'] for i, source_l in enumerate(an_t_list): if len(source_l) > 0: sim.Projection(input_pop, t_pops[i], sim.FromListConnector(source_l), synapse_type=sim.StaticSynapse()) duration = 100 #max(input_spikes[0]) sim.run(duration) for i, pop in enumerate(t_pops): t_data[i] = pop.get_data() # t_spikes[i] = t_data[i].segments[0].spiketrains sim.end() for i, cd_data in enumerate(t_data): plt.figure('spikes') non_zero_neuron_times = cd_data.segments[0].spiketrains
def do_run(): # 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, '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(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector(), additional_parameters=cell_params_spike_injector_with_key, label='spike_injector_forward') injector_backward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector(), additional_parameters=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(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection(injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) # Synfire chain connection where each neuron is connected to 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.StaticSynapse(weight=weight_to_spike, delay=3)) Frontend.Projection(pop_backward, pop_backward, Frontend.FromListConnector(loop_backward), Frontend.StaticSynapse(weight=weight_to_spike, delay=3)) # record spikes from the synfire chains so that we can read off valid # results in a safe way afterwards, and verify the behaviour pop_forward.record(['spikes']) pop_backward.record(['spikes']) # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_host="localhost", database_notify_port_num=19996) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_host="localhost", database_notify_port_num=19996) # Set up the live connection for sending spikes live_spikes_connection_send = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=None, local_port=NOTIFY_PORT, send_labels=["spike_injector_forward", "spike_injector_backward"]) # Set up callbacks to occur at initialisation live_spikes_connection_send.add_init_callback( "spike_injector_forward", init_pop) live_spikes_connection_send.add_init_callback( "spike_injector_backward", init_pop) # Set up callbacks to occur at the start of simulation live_spikes_connection_send.add_start_resume_callback( "spike_injector_forward", send_input_forward) live_spikes_connection_send.add_start_resume_callback( "spike_injector_backward", send_input_backward) live_spikes_connection_receive = None if not using_c_vis: # if not using the c visualiser, then a new spynnaker live spikes # connection is created to define that there is a python function which # receives the spikes. live_spikes_connection_receive = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=["pop_forward", "pop_backward"], local_port=19996, 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) Frontend.run(run_time) # Retrieve spikes from the synfire chain population spikes_forward = neo_convertor.convert_spikes( pop_forward.get_data('spikes')) spikes_backward = neo_convertor.convert_spikes( pop_backward.get_data('spikes')) # Clear data structures on spiNNaker to leave the machine in a clean state # for future executions Frontend.end() return (spikes_forward, spikes_backward)
# an2ch_weight = RandomDistribution('normal',[av_weight,0.1]) # an2ch_weight = RandomDistribution('normal',[av_weight,0.5]) # an2ch_weight = RandomDistribution('uniform',[0,av_weight+(av_weight*1.5)]) # an2ch_weight = RandomDistribution('uniform',[0.9*(w2s_target/conn_num),1.1*(w2s_target/conn_num)]) an2ch_weight = RandomDistribution('normal_clipped',[av_weight/2.,av_weight*0.5,0.,1.1*av_weight]) # plt.hist(an2ch_weight.next(1000),bins=100) # plt.show() an2ch_list = normal_dist_connection_builder(number_of_inputs,n_ch,RandomDistribution,conn_num,dist,sigma) pres = np.asarray([pre for (pre,post) in an2ch_list]) x= np.nonzero(pres==25) posts = np.asarray([post for (pre,post) in an2ch_list]) y = np.nonzero(posts==25) reduced_list = [(pre,post) for (pre,post) in an2ch_list if post == 500] pres = [pre for (pre,post) in reduced_list] an_ch_projection = sim.Projection(input_pop,ch_pop,sim.FromListConnector(an2ch_list),synapse_type=sim.StaticSynapse(weight=an2ch_weight)) # an_ch_projection = sim.Projection(input_pop,ch_pop,sim.FromListConnector(reduced_list),synapse_type=sim.StaticSynapse(weight=an2ch_weight)) #TODO: calculate formulas for these variables so we can scale an_scale_factor = number_of_inputs/30000. n_on_inputs = 10.#np.round(an_scale_factor*88.)#upper bound from Xie and Manis (2017) an_on_p_connect = n_on_inputs/float(number_of_inputs) # an_on_p_connect = 0.1#0.55 # an_on_weight = w2s_target/(n_on_inputs) # an_on_weight = 1.5/(n_on_inputs) av_weight = 0.05#0.05#0.015#0.005#0.002#0.00125#0.0055#0.005# # av_weight = 4.#0.005#0.002#0.00125#0.0055#0.005# # an_on_weight =RandomDistribution('uniform',[0.9*av_weight,1.1*av_weight]) an_on_weight =RandomDistribution('uniform',[0,av_weight]) # test = RandomDistribution('normal_clipped',[500,10*number_of_inputs,0,1000])
def do_run(plot): runtime = 3000 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(p.IF_curr_exp, 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 } populations = list() projections = list() weight_to_spike = 2.0 delay = 10 # connection list in a loop for first population loopConnections = [] for i in range(0, nNeurons): singleConnection = ((i, (i + 1) % nNeurons)) loopConnections.append(singleConnection) # injection list to set the chain going injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} # list of populations 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')) populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_3')) populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_4')) populations.append( p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1')) # Loop connector: we can just pass in the list we made earlier CSA_loop_connector = p.CSAConnector(loopConnections) # random connector: each connection has a probability of 0.05 CSA_random_connector = p.CSAConnector(csa.random(0.05)) # one-to-one connector: do I really need to explain? CSA_onetoone_connector = p.CSAConnector(csa.oneToOne) # This creates a block of size (5,10) with a probability of 0.05; then # within the block an individual connection has a probability of 0.3 csa_block_random = csa.block(15, 10) * csa.random(0.05) * csa.random(0.3) CSA_randomblock_connector = p.CSAConnector(csa_block_random) # list of projections using the connectors above projections.append( p.Projection(populations[0], populations[0], CSA_loop_connector, p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[0], populations[1], CSA_random_connector, p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[1], populations[2], CSA_onetoone_connector, p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[2], populations[3], CSA_randomblock_connector, p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[4], populations[0], p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1))) populations[0].record(['v', 'spikes']) populations[1].record(['v', 'spikes']) populations[2].record(['v', 'spikes']) populations[3].record(['v', 'spikes']) p.run(runtime) # get data (could be done as one, but can be done bit by bit as well) v = populations[0].spinnaker_get_data('v') v2 = populations[1].spinnaker_get_data('v') v3 = populations[2].spinnaker_get_data('v') v4 = populations[3].spinnaker_get_data('v') spikes = populations[0].spinnaker_get_data('spikes') spikes2 = populations[1].spinnaker_get_data('spikes') spikes3 = populations[2].spinnaker_get_data('spikes') spikes4 = populations[3].spinnaker_get_data('spikes') if plot: # Use the show functionality of CSA to display connection sets CSA_loop_connector.show_connection_set() CSA_random_connector.show_connection_set() CSA_onetoone_connector.show_connection_set() CSA_randomblock_connector.show_connection_set() # Now plot some spikes pylab.figure() pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], "r.") pylab.xlabel('Time/ms') pylab.ylabel('spikes') pylab.title('spikes: population 1') pylab.show() pylab.figure() pylab.plot([i[1] for i in spikes3], [i[0] for i in spikes3], "g.") pylab.plot([i[1] for i in spikes4], [i[0] for i in spikes4], "r.") pylab.plot([i[1] for i in spikes2], [i[0] for i in spikes2], "b.") pylab.xlabel('Time/ms') pylab.ylabel('spikes') pylab.title('spikes: populations 2, 3, 4') pylab.show() p.end() return v, v2, v3, v4, spikes, spikes2, spikes3, spikes4
[5, 0, weight, 1], [9, 0, weight, 1]] left = 0 right = 1 from_list_conn_out = [[0, left, weight, 1], [6, left, weight, 1], [3, left, weight, 1], [11, left, weight, 1], [2, right, weight, 1], [8, right, weight, 1], [5, right, weight, 1], [9, right, weight, 1]] output_pop = p.Population(outputs, p.IF_cond_exp(tau_m=0.5, tau_refrac=0, v_thresh=-64, tau_syn_E=1, tau_syn_I=1), label='out') output_pop.record(['spikes', 'v', 'gsyn_exc']) p.Projection(pendulum, output_pop, p.FromListConnector(from_list_conn_out)) output_pop2 = p.Population(outputs, p.IF_cond_exp(tau_m=0.5, tau_refrac=0, v_thresh=-64, tau_syn_E=0.5, tau_syn_I=0.5), label='out2') output_pop2.record(['spikes', 'v', 'gsyn_exc']) p.Projection(null_pop, output_pop2, p.FromListConnector(from_list_conn_out)) arm_conns = [from_list_conn_left, from_list_conn_right] # for j in range(outputs): # arm_collection.append(p.Population( # int(np.ceil(np.log2(outputs))), # Arm(arm_id=j, reward_delay=exposure_time, # rand_seed=[np.random.randint(0xffff) for k in range(4)],
def run_multiple_stdp_mechs_on_same_neuron(self, mode="same"): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) nNeurons = 200 # number of neurons in each population 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 connections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) # Plastic Connection between pre_pop and post_pop stdp_model1 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=16.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.AdditiveWeightDependence( w_min=0.0, w_max=1.0), ) # Plastic Connection between pre_pop and post_pop stdp_model2 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=16.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.AdditiveWeightDependence( w_min=0.0, w_max=1.0), ) # Plastic Connection between pre_pop and post_pop if mode == "same": stdp_model3 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=16.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.AdditiveWeightDependence( w_min=0.0, w_max=1.0), ) elif mode == "weight_dependence": stdp_model3 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=16.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.MultiplicativeWeightDependence( w_min=0.0, w_max=1.0), ) elif mode == "tau": stdp_model3 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=15.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.AdditiveWeightDependence( w_min=0.0, w_max=1.0), ) elif mode == "wmin": stdp_model3 = p.STDPMechanism( timing_dependence=p.SpikePairRule( tau_plus=16.7, tau_minus=33.7, A_plus=0.005, A_minus=0.005), weight_dependence=p.AdditiveWeightDependence(w_min=1.0, w_max=1.0), ) else: raise Exception(mode) injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray1 = {'spike_times': [[0]]} spikeArray2 = {'spike_times': [[25]]} spikeArray3 = {'spike_times': [[50]]} spikeArray4 = {'spike_times': [[75]]} spikeArray5 = {'spike_times': [[100]]} spikeArray6 = {'spike_times': [[125]]} spikeArray7 = {'spike_times': [[150]]} spikeArray8 = {'spike_times': [[175]]} populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray1, label='inputSpikes_1')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray2, label='inputSpikes_2')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray3, label='inputSpikes_3')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray4, label='inputSpikes_4')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray5, label='inputSpikes_5')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray6, label='inputSpikes_6')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray7, label='inputSpikes_7')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray8, label='inputSpikes_8')) projections.append(p.Projection(populations[0], populations[0], p.FromListConnector(connections))) pop = p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection)) pop = p.Projection(populations[2], populations[0], p.FromListConnector(injectionConnection), synapse_type=stdp_model1) projections.append(pop) # This is expected to raise a SynapticConfigurationException pop = p.Projection(populations[3], populations[0], p.FromListConnector(injectionConnection), synapse_type=stdp_model2) projections.append(pop) pop = p.Projection(populations[4], populations[0], p.FromListConnector(injectionConnection), synapse_type=stdp_model3) projections.append(pop)
(i, j, inhibition_weight_multiplier * w_max, 1)) if args.rewiring and not args.fixed_wta: wta_projection = sim.Projection( readout_pop, readout_pop, sim.FixedProbabilityConnector(0.), synapse_type=structure_model_w_stdp, label="wta_strong_inhibition_readout_rewired", receptor_type="inhibitory") else: wta_projection = sim.Projection( readout_pop, readout_pop, sim.FromListConnector(all_to_all_connections), label="wta_strong_inhibition_readout", receptor_type="inhibitory") elif phase == TESTING_PHASE: # Extract static connectivity from the training phase # Retrieve readout connectivity (ff and lat) # Always retrieve ff connectivity if snapshots_present: trained_target_readout_connectivity = \ target_snapshots[snap_keys[snap]] trained_wta_connectivity = \ wta_snapshots[snap_keys[snap]] else: trained_target_readout_connectivity = \ readout_training_data['target_readout_projection'][-1]
def structural_shared(): p.setup(1.0) pre_spikes = numpy.array(range(0, 10, 2)) A_plus = 0.01 A_minus = 0.01 tau_plus = 20.0 tau_minus = 20.0 w_min = 0.0 w_max = 5.0 w_init = 5.0 delay_init = 2.0 stim = p.Population(1, p.SpikeSourceArray(pre_spikes), label="stim") pop = p.Population(1, p.IF_curr_exp(), label="pop") pop_2 = p.Population(1, p.IF_curr_exp(), label="pop_2") pop_3 = p.Population(1, p.IF_curr_exp(), label="pop_3") pop_4 = p.Population(1, p.IF_curr_exp(), label="pop_4") pop.record("spikes") pop_2.record("spikes") struct_pl_static = p.StructuralMechanismStatic( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(2.0, 0, 0), f_rew=1000, initial_weight=w_init, initial_delay=delay_init, s_max=1, seed=0, weight=0.0, delay=1.0) struct_pl_stdp = p.StructuralMechanismSTDP( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), timing_dependence=p.SpikePairRule( tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=2.0, initial_delay=5.0, s_max=1, seed=0, weight=0.0, delay=1.0) proj = p.Projection( stim, pop, p.FromListConnector([]), struct_pl_static) proj_2 = p.Projection( stim, pop_2, p.FromListConnector([]), struct_pl_static) proj_3 = p.Projection( stim, pop_3, p.FromListConnector([(0, 0)]), struct_pl_stdp) proj_4 = p.Projection( stim, pop_4, p.FromListConnector([(0, 0)]), struct_pl_stdp) p.Projection(pop_3, pop_4, p.AllToAllConnector(), p.StaticSynapse(weight=1, delay=3)) p.run(10) conns = list(proj.get(["weight", "delay"], "list")) conns_2 = list(proj_2.get(["weight", "delay"], "list")) conns_3 = list(proj_3.get(["weight", "delay"], "list")) conns_4 = list(proj_4.get(["weight", "delay"], "list")) p.end() print(conns) print(conns_2) print(conns_3) print(conns_4) assert(len(conns) == 1) assert(tuple(conns[0]) == (0, 0, w_init, delay_init)) assert(len(conns_2) == 1) assert(tuple(conns_2[0]) == (0, 0, w_init, delay_init)) assert(len(conns_3) == 0) assert(len(conns_4) == 0)
def do_synfire_npop(nNeurons, n_pops, neurons_per_core, runtime=25000): """ Runs the script Does the run based on the parameters :param nNeurons: Number of Neurons in chain :type nNeurons: int :param n_pops: Number of populations :type n_pops: int :param neurons_per_core: Number of neurons per core :type neurons_per_core: int :param runtime: time to run the script for :type runtime: int """ p.setup(timestep=1.0) RootTestCase.assert_not_spin_three() p.set_number_of_neurons_per_core(p.IF_curr_exp, neurons_per_core) 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 connections = list() for i in range(0, nNeurons - 1): singleConnection = (i, i + 1, weight_to_spike, delay) connections.append(singleConnection) pop_jump_connection = [(nNeurons - 1, 0, weight_to_spike, 1)] injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0]]} for i in range(0, n_pops): populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_{}'.format(i))) populations.append( p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1')) for i in range(0, n_pops): projections.append( p.Projection(presynaptic_population=populations[i], postsynaptic_population=populations[i], connector=p.FromListConnector(connections), synapse_type=p.StaticSynapse())) connector = p.FromListConnector(pop_jump_connection) projections.append( p.Projection(presynaptic_population=populations[i], postsynaptic_population=populations[((i + 1) % n_pops)], connector=connector, synapse_type=p.StaticSynapse())) projections.append( p.Projection(presynaptic_population=populations[n_pops], postsynaptic_population=populations[0], connector=p.FromListConnector(injectionConnection), synapse_type=p.StaticSynapse())) for pop_index in range(0, n_pops): populations[pop_index].record("spikes") p.run(runtime) total_spikes = populations[0].spinnaker_get_data("spikes") for pop_index in range(1, n_pops): spikes = populations[pop_index].spinnaker_get_data("spikes") if spikes is not None: for spike in spikes: spike[0] += (nNeurons * pop_index) total_spikes = numpy.concatenate((total_spikes, spikes), axis=0) p.end() return total_spikes
def do_run(): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) nNeurons = 100 # number of neurons in each population 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 = 3 delays = list() connections = list() for i in range(0, nNeurons): delays.append(float(delay)) singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'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(**spikeArray), label='inputSpikes_1')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections), p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1))) populations[0].record(['spikes']) p.external_devices.activate_live_output_for(populations[0]) populations[0].add_placement_constraint(0, 0, 2) populations[1].add_placement_constraint(0, 0, 3) run_time = 1000 print("Running for {} ms".format(run_time)) p.run(run_time) spikes = neo_convertor.convert_spikes(populations[0].get_data('spikes')) p.end() return spikes
t2 = [[2, 3, 4, 8], [2, 4, 6, 8]] t1 = [2, 12] input_celltype = sim.SpikeSourceArray(spike_times=t1) fc_celltype = sim.IF_cond_exp(**cellparams) pop0 = sim.Population(1, input_celltype) pop1 = sim.Population(1, fc_celltype) pop1.initialize(**cellvalues) #pop1.set(i_offset=b) pop1.record(['spikes', 'v']) pop0.record(['spikes']) # create synapsis conn = sim.FromListConnector(w1) pro = sim.Projection(pop0, pop1, connector=conn) sim.run(duration) mem = pop1.get_data().segments[-1].filter(name='v')[0] from pyNN.utility.plotting import Figure, Panel Figure( Panel(mem, ylabel="Membrane potential (mV)", xticks=True, xlabel="Time (ms)", yticks=True))
loopConnections = list() for i in range(0, nNeurons): singleConnection = ((i, (i + 1) % nNeurons, weight_to_spike, delay)) loopConnections.append(singleConnection) injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} main_pop = p.Population(nNeurons, p.IF_cond_exp(**cell_params_lif), label='pop_1') input_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') p.Projection(main_pop, main_pop, p.FromListConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay)) p.Projection(input_pop, main_pop, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1)) main_pop.record(['v', 'gsyn_exc', 'gsyn_inh', 'spikes']) intercept_simulator(p, "sim_synfire_if_cond_exp") from importlib import reload p = reload(p) populations, projections = restore_simulator_from_file( p, "sim_synfire_if_cond_exp") p.run(runtime)
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, Frontend.external_devices.SpikeInjector(), label='spike_injector_forward', additional_parameters=cell_params_spike_injector_with_key) injector_backward = Frontend.Population( self.n_neurons, Frontend.external_devices.SpikeInjector(), label='spike_injector_backward', additional_parameters=cell_params_spike_injector) 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(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection(injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=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('spikes') pop_backward.record('spikes') # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_host="localhost", database_notify_port_num=19996) Frontend.external_devices.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 = \ Frontend.external_devices.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.get_data('spikes') spikes_backward = pop_backward.get_data('spikes') # Clear data structures on spiNNaker to leave the machine in a clean # state for future executions Frontend.end() if use_spike_injector: p.join() Figure( # raster plot of the presynaptic neuron spike times Panel(spikes_forward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), Panel(spikes_backward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), title="Simple synfire chain example with injected spikes", annotations="Simulated with {}".format(Frontend.name())) plt.show()
slots_starts = np.ones((N_layer, number_of_slots)) * (range_of_slots * t_stim) durations = np.ones((N_layer, number_of_slots)) * t_stim rates = np.random.randint(1, 5, size=(N_layer, number_of_slots)) # Spike sources poisson_spike_source = sim.Population(N_layer, SpikeSourcePoissonVariable( starts=slots_starts, rates=rates, durations=durations), label='poisson_source') lif_pop = sim.Population(N_layer, sim.IF_curr_exp, label='pop_1') conns = [[x, x] for x in range(N_layer)] sim.Projection(poisson_spike_source, lif_pop, sim.FromListConnector(conns), sim.StaticSynapse(weight=2, delay=1)) poisson_spike_source.record(['spikes']) lif_pop.record(['spikes']) intercept_simulator(sim, "variable_rate_pss") sim.run(runtime) pss_spikes = poisson_spike_source.spinnaker_get_data('spikes') lif_spikes = lif_pop.spinnaker_get_data('spikes') sim.end() from importlib import reload sim = reload(sim) populations, projections, _ = restore_simulator_from_file(
def _connect_spike_sources(self, retinae=None, verbose=False): if verbose: print "INFO: Connecting Spike Sources to Network." global _retina_proj_l, _retina_proj_r # left is 0--dimensionRetinaY-1; right is dimensionRetinaY--dimensionRetinaY*2-1 connListRetLBlockerL = [] connListRetLBlockerR = [] connListRetRBlockerL = [] connListRetRBlockerR = [] for y in range(0, self.dim_y): connListRetLBlockerL.append((y, y, self.cell_params['synaptic']['wSaB'], self.cell_params['synaptic']['dSaB'])) connListRetLBlockerR.append((y, y + self.dim_y, self.cell_params['synaptic']['wSzB'], self.cell_params['synaptic']['dSzB'])) connListRetRBlockerL.append((y, y, self.cell_params['synaptic']['wSzB'], self.cell_params['synaptic']['dSzB'])) connListRetRBlockerR.append((y, y + self.dim_y, self.cell_params['synaptic']['wSaB'], self.cell_params['synaptic']['dSaB'])) retinaLeft = retinae['left'].pixel_columns retinaRight = retinae['right'].pixel_columns pixel = 0 for row in _retina_proj_l: for pop in row: ps.Projection(retinaLeft[pixel], self.network[pop][1], ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wSC'], delay=self.cell_params['synaptic']['dSC']), receptor_type='excitatory') #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wSC'], # delays=self.cell_params['synaptic']['dSC']), #target='excitatory') ps.Projection(retinaLeft[pixel], self.network[pop][0], ps.FromListConnector(connListRetLBlockerL), receptor_type='excitatory') #target='excitatory') ps.Projection(retinaLeft[pixel], self.network[pop][0], ps.FromListConnector(connListRetLBlockerR), receptor_type='inhibitory') #target='inhibitory') pixel += 1 pixel = 0 for col in _retina_proj_r: for pop in col: ps.Projection(retinaRight[pixel], self.network[pop][1], ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wSC'], delay=self.cell_params['synaptic']['dSC']), receptor_type='excitatory') #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wSC'], # delays=self.cell_params['synaptic']['dSC']), #target='excitatory') ps.Projection(retinaRight[pixel], self.network[pop][0], ps.FromListConnector(connListRetRBlockerR), receptor_type='excitatory') #target='excitatory') ps.Projection(retinaRight[pixel], self.network[pop][0], ps.FromListConnector(connListRetRBlockerL), receptor_type='inhibitory') #target='inhibitory') pixel += 1
label=label) # Set the rest of the specified variables, if any. for variable in s['variables']: if getattr(population, variable, None) is None: setattr(population, variable, s[label][variable]) if label != 'InputLayer': population.set(i_offset=s[label]['i_offset']) layers.append(population) print('assembly loaded') # ------ Load weights and delays -------- for i in range(len(layers) - 1): print('Loading connections for layer ' + str(layers[i].label)) filepath = os.path.join(layers_path, layers[i + 1].label) conn_list = read_from_file2list(filepath) exc_connector = sim.FromListConnector(conn_list[0]) pro_exc = sim.Projection(layers[i], layers[i + 1], connector=exc_connector, receptor_type='excitatory') if conn_list[1] != []: inh_connector = sim.FromListConnector(read_from_file2list(filepath)[1]) pro_inh = sim.Projection(layers[i], layers[i + 1], connector=inh_connector, receptor_type='inhibitory') print('connections loaded') # -------- Cell initialization ----------- vars_to_record = ['spikes', 'v'] if 'spikes' in vars_to_record:
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) cm = list() i_off = list() tau_m = list() tau_re = list() tau_syn_e = list() tau_syn_i = list() v_reset = list() v_rest = list() v_thresh = list() for atom in range(0, nNeurons): cm.append(0.25) i_off.append(0.0) tau_m.append(10.0) tau_re.append(2.0) tau_syn_e.append(0.5) tau_syn_i.append(0.5) v_reset.append(-65.0) v_rest.append(-65.0) v_thresh.append(-64.4) gbar_na_distr = RandomDistribution('normal', (20.0, 2.0), rng=NumpyRNG(seed=85524)) cell_params_lif = { 'cm': cm, 'i_offset': i_off, 'tau_m': tau_m, 'tau_refrac': tau_re, 'tau_syn_E': tau_syn_e, 'tau_syn_I': tau_syn_i, 'v_reset': v_reset, 'v_rest': v_rest, 'v_thresh': v_thresh } populations = list() projections = list() weight_to_spike = 2 delay = 1 connections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, delay)] spikeArray = {'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, spikeArray, label='inputSpikes_1')) populations[0].set(cm=0.25) populations[0].set(cm=cm) populations[0].set(tau_m=tau_m, v_thresh=v_thresh) populations[0].set(i_offset=gbar_na_distr) populations[0].set(i_offset=i_off) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") p.run(100) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) p.end() return neo
def structural_with_stdp(): p.setup(1.0) pre_spikes = numpy.array(range(0, 10, 2)) pre_spikes_last_neuron = pre_spikes[pre_spikes > 0] A_plus = 0.01 A_minus = 0.01 tau_plus = 20.0 tau_minus = 20.0 w_min = 0.0 w_max = 5.0 w_init_1 = 5.0 delay_1 = 2.0 w_init_2 = 4.0 delay_2 = 1.0 stim = p.Population(1, p.SpikeSourceArray(pre_spikes), label="stim") pop = p.Population(1, p.IF_curr_exp(), label="pop") pop_2 = p.Population(1, p.IF_curr_exp(), label="pop_2") pop_3 = p.Population(1, p.IF_curr_exp(), label="pop_3") pop_4 = p.Population(1, p.IF_curr_exp(), label="pop_4") pop.record("spikes") pop_2.record("spikes") proj = p.Projection( stim, pop, p.FromListConnector([]), p.StructuralMechanismSTDP( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(2.0, 0, 0), timing_dependence=p.SpikePairRule( tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=w_init_1, initial_delay=delay_1, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_2 = p.Projection( stim, pop_2, p.FromListConnector([]), p.StructuralMechanismSTDP( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 1.0), elimination=p.RandomByWeightElimination(4.0, 0, 0), timing_dependence=p.SpikePairRule( tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=w_init_2, initial_delay=delay_2, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_3 = p.Projection( stim, pop_3, p.FromListConnector([(0, 0)]), p.StructuralMechanismSTDP( partner_selection=p.LastNeuronSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), timing_dependence=p.SpikePairRule( tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=2.0, initial_delay=5.0, s_max=1, seed=0, weight=0.0, delay=1.0)) proj_4 = p.Projection( stim, pop_4, p.FromListConnector([(0, 0)]), p.StructuralMechanismSTDP( partner_selection=p.RandomSelection(), formation=p.DistanceDependentFormation([1, 1], 0.0), elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0), timing_dependence=p.SpikePairRule( tau_plus, tau_minus, A_plus, A_minus), weight_dependence=p.AdditiveWeightDependence(w_min, w_max), f_rew=1000, initial_weight=4.0, initial_delay=3.0, s_max=1, seed=0, weight=0.0, delay=1.0)) p.run(10) conns = list(proj.get(["weight", "delay"], "list")) conns_2 = list(proj_2.get(["weight", "delay"], "list")) conns_3 = list(proj_3.get(["weight", "delay"], "list")) conns_4 = list(proj_4.get(["weight", "delay"], "list")) spikes_1 = [s.magnitude for s in pop.get_data("spikes").segments[0].spiketrains] spikes_2 = [s.magnitude for s in pop_2.get_data("spikes").segments[0].spiketrains] p.end() print(conns) print(conns_2) print(conns_3) print(conns_4) w_final_1 = calculate_spike_pair_additive_stdp_weight( pre_spikes_last_neuron, spikes_1[0], w_init_1, delay_1, w_max, A_plus, A_minus, tau_plus, tau_minus) w_final_2 = calculate_spike_pair_additive_stdp_weight( pre_spikes, spikes_2[0], w_init_2, delay_2, w_max, A_plus, A_minus, tau_plus, tau_minus) print(w_final_1, spikes_1[0]) print(w_final_2, spikes_2[0]) assert(len(conns) == 1) assert(conns[0][3] == delay_1) assert(conns[0][2] >= w_final_1 - 0.01 and conns[0][2] <= w_final_1 + 0.01) assert(len(conns_2) == 1) assert(conns_2[0][3] == delay_2) assert(conns_2[0][2] >= w_final_2 - 0.01 and conns_2[0][2] <= w_final_2 + 0.01) assert(len(conns_3) == 0) assert(len(conns_4) == 0)
def do_run(plot): p.setup(timestep=1.0) 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': -40.0 } # Parameters n = 10 weight_to_spike = 5.0 delay = 5 runtime = 200 # Populations exc_pop = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='exc_pop') inh_pop = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='inh_pop') # SpikeInjector injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, exc_pop, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Set up fromfileconnectors by writing to file connection_list1 = [ (0, 0, 0.1, 0.1), (3, 0, 0.2, 0.11), (2, 3, 0.3, 0.12), (5, 1, 0.4, 0.13), (0, 1, 0.5, 0.14), ] path1 = "test1.connections" if os.path.exists(path1): os.remove(path1) current_file_path = os.path.dirname(os.path.abspath(__file__)) file1 = os.path.join(current_file_path, path1) numpy.savetxt(file1, connection_list1) file_connector1 = p.FromFileConnector(file1) connection_list2 = [ (4, 9, 0.3, 0.12), (1, 5, 0.4, 0.13), (7, 6, 0.1, 0.1), (6, 5, 0.5, 0.14), (8, 2, 0.2, 0.11), ] path2 = "test2.connections" if os.path.exists(path2): os.remove(path2) file2 = path2 numpy.savetxt(file2, connection_list2) file_connector2 = p.FromFileConnector(file2) # Projections within populations p.Projection(exc_pop, inh_pop, file_connector1, p.StaticSynapse(weight=2.0, delay=5)) p.Projection(inh_pop, exc_pop, file_connector2, p.StaticSynapse(weight=1.5, delay=10)) exc_pop.record(['v', 'spikes']) inh_pop.record(['v', 'spikes']) p.run(runtime) v_exc = exc_pop.get_data('v') spikes_exc = exc_pop.get_data('spikes') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes_exc.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v_exc.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[exc_pop.label], yticks=True, xlim=(0, runtime), xticks=True), title="Testing FromFileConnector", annotations="Simulated with {}".format(p.name()) ) plt.show() p.end() return v_exc, spikes_exc
cd_pop.record("all") #================================================================================================ # Projections #================================================================================================ n_an_b_connections = RandomDistribution('uniform',[2.,5.]) w2s_b = 5.# av_an_b = w2s_b/5. an_b_weight = RandomDistribution('normal_clipped',[av_an_b,0.1*av_an_b,0,av_an_b*2.]) an_b_list, max_dist = normal_dist_connection_builder(number_of_inputs, n_b, RandomDistribution, conn_num=n_an_b_connections, dist=1., sigma=1., conn_weight=an_b_weight, delay=timestep, normalised_space=pop_size, get_max_dist=True) # sim.Projection(input_pop,cd_pop,sim.FromListConnector([(0,0)]),synapse_type=sim.StaticSynapse(weight=w2s_b)) sim.Projection(input_pop, cd_pop, sim.FromListConnector(an_b_list), synapse_type=sim.StaticSynapse()) # sim.Projection(input_pop, cd_pop_2, sim.FromListConnector(an_b_list), # synapse_type=sim.StaticSynapse()) duration = test_dur_ms#max(input_spikes[0]) sim.run(duration) cd_data =[] cd_data.append(cd_pop.get_data()) # input_data = input_pop.get_data() sim.end()
input = sim.Population(1, sim.SpikeSourceArray(spike_times=[[0], [1]]), label="input") pop = sim.Population(n_neurons, sim.IF_curr_exp(tau_syn_E=5), label="pop") loop_conns = list() for i in range(0, n_neurons - 1): single_connection = (i, i + 1, weight_to_spike, delay) loop_conns.append(single_connection) single_connection = (n_neurons - 1, 0, weight_to_spike, delay) loop_conns.append(single_connection) print loop_conns input_proj = sim.Projection(input, pop, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=2)) loop_proj = sim.Projection(pop, pop, sim.FromListConnector(loop_conns)) pop.record(["spikes", "v"]) sim.run(simtime) s_neo = pop.get_data(variables=["spikes"]) spikes = s_neo.segments[0].spiketrains print spikes v_neo = pop.get_data(variables=["v"]) v = v_neo.segments[0].filter(name='v')[0] print v print "shape" print v.shape sim.end()
def test_sender(): # a new spynnaker live spikes connection is created to define that there is # a python function which receives the spikes. live_spikes_connection_receive = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=["pop_forward", "pop_backward"], local_port=None, 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) ############################################################ # Start the external sender # ############################################################ sender = subprocess.Popen(binary_path("sender"), stderr=subprocess.PIPE) firstline = str(sender.stderr.readline(), "UTF-8") match = re.match("^Listening on (.*)$", firstline) if not match: receiver.kill() raise Exception(f"Sender returned unknown output: {firstline}") sender_port = int(match.group(1)) ############################################################ # Setup a Simulation to be injected into and received from # ############################################################ # initial call to set up the front end (pynn requirement) Frontend.setup(timestep=1.0, min_delay=1.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 } ################################## # Parameters for the injector population. # The virtual key is assigned here, rather than being allocated later. # Spikes injected need to match this key, and this will be done automatically # with 16-bit keys. ################################## cell_params_spike_injector_with_key = { # 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(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population(n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector( database_notify_port_num=sender_port), label='spike_injector_forward', additional_parameters=cell_params_spike_injector_with_key) injector_backward = Frontend.Population( n_neurons, Frontend.external_devices.SpikeInjector( database_notify_port_num=sender_port), label='spike_injector_backward') # Create a connection from the injector into the populations Frontend.Projection(injector_forward, pop_forward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection(injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=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)) # 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('spikes') pop_backward.record('spikes') # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_port_num=live_spikes_connection_receive.local_port) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_port_num=live_spikes_connection_receive.local_port) # Run the simulation on spiNNaker Frontend.run(run_time) spikes_forward = pop_forward.get_data('spikes').segments[0].spiketrains spikes_backward = pop_backward.get_data('spikes').segments[0].spiketrains # Clear data structures on spiNNaker to leave the machine in a clean state # for future executions Frontend.end() print("Waiting for sender to stop...") sender.wait() print("Done") n_spikes = sum(len(s) for s in spikes_forward) n_spikes += sum(len(s) for s in spikes_backward) # Some sent spikes might get lost; 6 sent, 3 is fine assert (n_spikes >= 300)
def __create_synfire_chain(n_neurons, cell_class, cell_params, use_wrap_around_connections, weight_to_spike, delay, spike_times, spike_times_list, placement_constraint, randomise_v_init, seed, constraint, input_class, rate, start_time, duration, use_spike_connections): """ This actually builds the synfire chain. """ populations = list() projections = list() loop_connections = list() if use_wrap_around_connections: for i in range(0, n_neurons): single_connection = \ (i, ((i + 1) % n_neurons), weight_to_spike, delay) loop_connections.append(single_connection) else: for i in range(0, n_neurons - 1): single_connection = (i, i + 1, weight_to_spike, delay) loop_connections.append(single_connection) injection_connection = [(0, 0, weight_to_spike, 1)] run_count = 0 if spike_times_list is None: spike_array = {'spike_times': spike_times} else: spike_array = {'spike_times': spike_times_list[run_count]} populations.append( p.Population(n_neurons, cell_class(**cell_params), label='pop_1')) if placement_constraint is not None: if len(placement_constraint) == 2: (x, y) = placement_constraint populations[0].add_placement_constraint(x=x, y=y) else: (x, y, proc) = placement_constraint populations[0].add_placement_constraint(x=x, y=y, p=proc) if randomise_v_init: if seed is None: v_init = p.RandomDistribution('uniform', [-60, -40]) else: v_init = p.RandomDistribution('uniform', [-60, -40], NumpyRNG(seed=seed)) populations[0].initialize(v=v_init) if constraint is not None: populations[0].set_constraint(constraint) if input_class == SpikeSourceArray: populations.append( p.Population(1, input_class(**spike_array), label='inputSSA_1')) elif seed is None: populations.append( p.Population(1, input_class(rate=rate, start=start_time, duration=duration), label='inputSSP_1')) else: populations.append( p.Population(1, input_class(rate=rate, start=start_time, duration=duration, seed=seed), label='inputSSP_1')) # handle projections if use_spike_connections: projections.append( p.Projection( populations[0], populations[0], p.FromListConnector(loop_connections), p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injection_connection), p.StaticSynapse(weight=weight_to_spike, delay=1))) return populations, projections, run_count
def make_inference_network(self, weights=None): self.populations['spike_sender'] = Frontend.Population( self.n_neurons, ExternalDevices.SpikeInjector(), additional_parameters={'port': 12345}, label="spike_sender") self.populations['cann_pop'] = Frontend.Population( self.n_neurons, Frontend.IF_curr_exp(), #**neuron_params), label="cann_pop") self.populations['inh_pop'] = Frontend.Population( 1, Frontend.IF_curr_exp(), #**neuron_params), label="inh_pop") Frontend.Projection( self.populations['spike_sender'], self.populations['cann_pop'], Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=self.weight_input2cann, delay=self.delay_input2cann)) self.projections['cann2inh'] = Frontend.Projection( self.populations['cann_pop'], self.populations['inh_pop'], Frontend.AllToAllConnector(), synapse_type=Frontend.StaticSynapse(weight=self.weight_cann2inh, delay=self.delay_cann2inh), receptor_type="excitatory") self.projections['inh2cann'] = Frontend.Projection( self.populations['inh_pop'], self.populations['cann_pop'], Frontend.AllToAllConnector(), synapse_type=Frontend.StaticSynapse(weight=self.weight_inhibitory, delay=self.delay_inh2cann), receptor_type="inhibitory") # LEGI logic for a ring network for i in range(self.n_neurons): for j in range(self.n_neurons): self.dist[i][j] = abs(i - j) % (self.n_neurons) if self.dist[i][j] > self.n_neurons / 2: self.dist[i][j] = self.n_neurons - self.dist[i][j] self.weights[i][j] = round(self.weight_to_spike * \ (1 / (self.sig * np.sqrt(2 * np.pi)) * \ (np.exp(-np.power(self.dist[i][j] - self.mu, 2.) \ / (2 * np.power(self.sig, 2.))))), 2) self.cann_connector.append( (i, j, self.weights[i][j], self.delay_cann2cann)) # print "Distance matrix:\n", self.dist print "Weight matrix:\n", self.weights # print "CANN connector:\n",self.cann_connector self.projections['cann2cann'] = Frontend.Projection( self.populations['cann_pop'], self.populations['cann_pop'], Frontend.FromListConnector(self.cann_connector), receptor_type="excitatory") ExternalDevices.activate_live_output_for( self.populations['cann_pop'], database_notify_host="localhost", database_notify_port_num=19996) ExternalDevices.activate_live_output_for( self.populations['inh_pop'], database_notify_host="localhost", database_notify_port_num=19998) # Recording the values from populations during simulation self.populations['cann_pop'].record('spikes') self.populations['inh_pop'].record('spikes') self.populations['cann_pop'].record('v') self.populations['inh_pop'].record('v') self.populations['spike_sender'].record('spikes')
# Set up the PushBot control pushbot = p.Population(len(devices), p.external_devices.PushBotLifSpinnakerLink( protocol=pushbot_protocol, devices=devices, tau_syn_E=500.0), label="PushBot") # Send in some spikes stimulation = p.Population( len(devices), p.SpikeSourceArray(spike_times=[[i * 1000] for i in range(len(devices))]), label="input") connections = [(i, i, weights[device], 1) for i, device in enumerate(devices)] p.Projection(stimulation, pushbot, p.FromListConnector(connections)) retina_resolution = \ p.external_devices.PushBotRetinaResolution.DOWNSAMPLE_64_X_64 pushbot_retina = p.Population( retina_resolution.value.n_neurons, p.external_devices.PushBotSpiNNakerLinkRetinaDevice( spinnaker_link_id=spinnaker_link, board_address=board_address, protocol=pushbot_protocol, resolution=retina_resolution)) viewer = p.external_devices.PushBotRetinaViewer(retina_resolution.value, port=17895) p.external_devices.activate_live_output_for(pushbot_retina, port=viewer.local_port,
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) p.set_number_of_neurons_per_core(p.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 } p.set_number_of_neurons_per_core(p.IF_cond_exp, nNeurons / 2) cell_params_cond = { '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 injectionConnection = [(0, 0, weight_to_spike, delay)] sinkConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_cond_exp, cell_params_cond, label='pop_cond')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_curr')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_2')) populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='sink_pop')) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) projections.append( p.Projection(populations[3], populations[2], p.FromListConnector(injectionConnection))) projections.append( p.Projection(populations[0], populations[4], p.FromListConnector(sinkConnection))) projections.append( p.Projection(populations[2], populations[4], p.FromListConnector(sinkConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") populations[2].record("v") populations[2].record("gsyn_exc") populations[2].record("spikes") p.run(500) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) cond_v = neo_convertor.convert_data(neo, name="v") cond_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") cond_spikes = neo_convertor.convert_spikes(neo) neo = populations[2].get_data(["v", "spikes", "gsyn_exc"]) curr_v = neo_convertor.convert_data(neo, name="v") curr_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") curr_spikes = neo_convertor.convert_spikes(neo) p.end() return (cond_v, cond_gsyn, cond_spikes, curr_v, curr_gsyn, curr_spikes)
loopConnections = list() for i in range(0, nNeurons): singleConnection = ((i, (i + 1) % nNeurons, weight_to_spike, delay)) loopConnections.append(singleConnection) injectionConnection = [(0, 0)] spikeArray = {'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(**spikeArray), label='inputSpikes_1')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1))) populations[0].record(['v', 'gsyn_exc', 'gsyn_inh', 'spikes']) # New Parts p.external_devices.activate_live_output_for(populations[0]) def receive_spikes(label, time, neuron_ids): print "Received spikes from population {}, neurons {} at time {}".format(
def _interconnect_neurons_inhexc(self, network, verbose=False): assert network is not None, \ "ERROR: Network is not initialised! Interconnecting for inhibitory and excitatory patterns failed." if verbose and self.cell_params['topological']['radius_i'] < self.dim_x: print "WARNING: Bad radius of inhibition. Uniquness constraint cannot be satisfied." if verbose and 0 <= self.cell_params['topological']['radius_e'] > self.dim_x: print "WARNING: Bad radius of excitation. " # create lists with inhibitory along the Retina Right projective line nbhoodInhL = [] nbhoodInhR = [] nbhoodExcX = [] nbhoodEcxY = [] # used for the triangular form of the matrix in order to remain within the square if verbose: print "INFO: Generating inhibitory and excitatory connectivity patterns." # generate rows limiter = self.max_disparity - self.min_disparity + 1 ensembleIndex = 0 while ensembleIndex < len(network): if ensembleIndex / (self.max_disparity - self.min_disparity + 1) > \ (self.dim_x - self.min_disparity) - (self.max_disparity - self.min_disparity) - 1: limiter -= 1 if limiter == 0: break nbhoodInhL.append([ensembleIndex + disp for disp in range(0, limiter)]) ensembleIndex += limiter ensembleIndex = len(network) # generate columns nbhoodInhR = [[x] for x in nbhoodInhL[0]] shiftGlob = 0 for x in nbhoodInhL[1:]: shiftGlob += 1 shift = 0 for e in x: if (shift + 1) % (self.max_disparity - self.min_disparity + 1) == 0: nbhoodInhR.append([e]) else: nbhoodInhR[shift + shiftGlob].append(e) shift += 1 # generate all diagonals for diag in map(None, *nbhoodInhL): sublist = [] for elem in diag: if elem is not None: sublist.append(elem) nbhoodExcX.append(sublist) # generate all y-axis excitation for x in range(0, self.dim_y): for e in range(1, self.cell_params['topological']['radius_e'] + 1): if x + e < self.dim_y: nbhoodEcxY.append( (x, x + e, self.cell_params['synaptic']['wCCe'], self.cell_params['synaptic']['dCCe'])) if x - e >= 0: nbhoodEcxY.append( (x, x - e, self.cell_params['synaptic']['wCCe'], self.cell_params['synaptic']['dCCe'])) # Store these lists as global parameters as they can be used to quickly match the spiking collector neuron # with the corresponding pixel xy coordinates (same_disparity_indices) # TODO: think of a better way to encode pixels: closed form formula would be perfect # These are also used when connecting the spike sources to the network! (retina_proj_l, retina_proj_r) global _retina_proj_l, _retina_proj_r, same_disparity_indices _retina_proj_l = nbhoodInhL _retina_proj_r = nbhoodInhR same_disparity_indices = nbhoodExcX if verbose: print "INFO: Connecting neurons for internal excitation and inhibition." for row in nbhoodInhL: for pop in row: for nb in row: if nb != pop: ps.Projection(network[pop][1], network[nb][1], #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCi'], # delays=self.cell_params['synaptic']['dCCi']), #target='inhibitory') ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wCCi'], delay=self.cell_params['synaptic']['dCCi']), receptor_type='inhibitory') for col in nbhoodInhR: for pop in col: for nb in col: if nb != pop: ps.Projection(network[pop][1], network[nb][1], ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wCCi'], delay=self.cell_params['synaptic']['dCCi']), #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCi'], # delays=self.cell_params['synaptic']['dCCi']), #target='inhibitory' receptor_type='inhibitory') for diag in nbhoodExcX: for pop in diag: for nb in range(1, self.cell_params['topological']['radius_e'] + 1): if diag.index(pop) + nb < len(diag): ps.Projection(network[pop][1], network[diag[diag.index(pop) + nb]][1], ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wCCe'], delay=self.cell_params['synaptic']['dCCe']), receptor_type='excitatory') #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCe'], # delays=self.cell_params['synaptic']['dCCe']), #target='excitatory') if diag.index(pop) - nb >= 0: ps.Projection(network[pop][1], network[diag[diag.index(pop) - nb]][1], ps.OneToOneConnector(), ps.StaticSynapse(weight=self.cell_params['synaptic']['wCCe'], delay=self.cell_params['synaptic']['dCCe']), receptor_type='excitatory') #ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCe'], # delays=self.cell_params['synaptic']['dCCe']), #target='excitatory') for ensemble in network: ps.Projection(ensemble[1], ensemble[1], ps.FromListConnector(nbhoodEcxY), receptor_type='excitatory')#target='excitatory')
timing_dependence=sim.SpikePairRule(tau_plus=tau_plus, tau_minus=tau_minus, A_plus=a_plus, A_minus=a_minus), weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=g_max), backprop_delay=False) elif case == CASE_CORR_NO_REW: structure_model_w_stdp = stdp_model # structure_model_w_stdp = sim.StructuralMechanism(weight=g_max, s_max=s_max) if not args.lesion: print("No insults") ff_projection = sim.Projection(source_pop, target_pop, sim.FromListConnector(init_ff_connections), synapse_type=structure_model_w_stdp, label="plastic_ff_projection") lat_projection = sim.Projection( target_pop, target_pop, sim.FromListConnector(init_lat_connections), synapse_type=structure_model_w_stdp, label="plastic_lat_projection", receptor_type="inhibitory" if args.lateral_inhibition else "excitatory") elif args.lesion == ONE_TO_ONE_LESION: # ff_pos = range(len(init_ff_connections)) # lat_pos = range(len(init_lat_connections)) # subsample_ff = np.random.choice(ff_pos, 10)
delay = 17 loopConnections = list() for i in range(0, nNeurons): singleConnection = ((i, (i + 1) % nNeurons, weight_to_spike, delay)) loopConnections.append(singleConnection) injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_1')) populations.append( p.Population(1, p.external_devices.SpikeInjector(), label='inputSpikes_1')) projections.append(p.Projection( populations[0], populations[0], p.FromListConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay))) projections.append(p.Projection( populations[1], populations[0], p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1))) populations[0].record(['v', 'gsyn_exc', 'gsyn_inh', 'spikes']) # New Parts p.external_devices.activate_live_output_for(populations[0]) def receive_spikes(label, time, neuron_ids): print "Received spikes from population {}, neurons {} at time {}".format( label, neuron_ids, time)