def live_spike_receive_translated(self): self.stored_data = list() db_conn = DatabaseConnection(local_port=None) db_conn.add_database_callback(self.database_callback) p.setup(1.0) p.set_number_of_neurons_per_core(p.SpikeSourceArray, 5) pop = p.Population( 25, p.SpikeSourceArray([[1000 + (i * 10)] for i in range(25)])) p.external_devices.activate_live_output_for( pop, translate_keys=True, database_notify_port_num=db_conn.local_port, tag=1, use_prefix=True, key_prefix=self.PREFIX, prefix_type=EIEIOPrefix.UPPER_HALF_WORD) p.run(1500) p.end() self.listener.close() self.conn.close() self.assertGreater(len(self.stored_data), 0) for key, time in self.stored_data: self.assertEqual(key >> 16, self.PREFIX) self.assertEqual(1000 + ((key & 0xFFFF) * 10), time)
def mapping_process(): ################################### SIM_TIME = TIME_SLOT*DATA_AMOUNT ## ################################### twitter_text_vectors = sentence_to_vec() orig = get_nearest_neighbor(twitter_text_vectors) show_result(orig,1,'./retrived_data/original_classification') response_space = generate_vr_response(twitter_text_vectors) spiking_space = generate_spiking_time(response_space) np.savetxt("./retrived_data/input_time.txt",spiking_space,fmt='%s',delimiter=',',newline='\n') spynnaker.setup(timestep=1) spynnaker.set_number_of_neurons_per_core(spynnaker.IF_curr_exp, 250) pn_population = setupLayer_PN(spiking_space) kc_population = setupLayer_KC() kc_population.record(["spikes"]) pn_kc_projection = setupProjection_PN_KC(pn_population,kc_population) spynnaker.run(SIM_TIME) neo = kc_population.get_data(variables=["spikes"]) spikeData_original= neo.segments[0].spiketrains spynnaker.end() return spikeData_original
def mapping_process(): assert SIM_TIME > 0 spynnaker.setup(timestep=1) spynnaker.set_number_of_neurons_per_core(spynnaker.IF_curr_exp, 50) time_space = readData() pn_population = setupLayer_PN(time_space) kc_population = setupLayer_KC() kc_population.record(["spikes"]) pn_kc_projection = setupProjection_PN_KC(pn_population, kc_population) spynnaker.run(SIM_TIME) neo = kc_population.get_data(variables=["spikes"]) spikeData_original = neo.segments[0].spiketrains spynnaker.end() return spikeData_original
def mapping_process(): ################################### SIM_TIME = TIME_SLOT * DATA_AMOUNT ## ################################### spynnaker.setup(timestep=1) spynnaker.set_number_of_neurons_per_core(spynnaker.IF_curr_exp, 50) # time_space = readData() # Manage to obtain data correctly pn_population = setupLayer_PN(time_space) kc_population = setupLayer_KC() kc_population.record(["spikes"]) pn_kc_projection = setupProjection_PN_KC(pn_population, kc_population) spynnaker.run(SIM_TIME) neo = kc_population.get_data(variables=["spikes"]) spikeData_original = neo.segments[0].spiketrains spynnaker.end() return spikeData_original
def mapping_process(): ################################### SIM_TIME = TIME_SLOT*DATA_AMOUNT ## ################################### response_space = generate_vr_response() spiking_space = generate_spiking_time(response_space) spynnaker.setup(timestep=1) spynnaker.set_number_of_neurons_per_core(spynnaker.IF_curr_exp, 250) pn_population = setupLayer_PN(spiking_space) kc_population = setupLayer_KC() kc_population.record(["spikes"]) pn_kc_projection = setupProjection_PN_KC(pn_population,kc_population) spynnaker.run(SIM_TIME) neo = kc_population.get_data(variables=["spikes"]) spikeData_original= neo.segments[0].spiketrains spynnaker.end() return spikeData_original
import pyNN.spiNNaker as sim import pyNN.utility.plotting as plot import matplotlib.pyplot as plt import threading from random import uniform from time import sleep from pykeyboard import PyKeyboard sim.setup(timestep=1.0) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100) input1 = sim.Population(6, sim.external_devices.SpikeInjector(), label="stateSpikeInjector") pre_pop = sim.Population(6, sim.IF_curr_exp(tau_syn_E=100, tau_refrac=50), label="statePopulation") post_pop = sim.Population(1, sim.IF_curr_exp(), label="actorPopulation") sim.external_devices.activate_live_output_for(pre_pop, database_notify_host="localhost", database_notify_port_num=19996) sim.external_devices.activate_live_output_for(input1, database_notify_host="localhost", database_notify_port_num=19998) timing_rule = sim.SpikePairRule(tau_plus=20.0, tau_minus=20.0, A_plus=0.5, A_minus=0.5)
mean_of_means = total_mean / len(means) total_std = 0 if len(stds) > 0: for val in stds: total_std += val mean_of_stds = total_std / len(stds) return (mean_of_means, mean_of_stds) if len(sys.argv) is not 4: print "Error: expected 3 parameters after filename, but got ", len(sys.argv)-1 quit() p.setup(timestep=1.0, min_delay = 1.0, max_delay = 15.0) p.set_number_of_neurons_per_core("IF_curr_exp", 50) p.set_number_of_neurons_per_core("SpikeSourcePoisson", poissonSourcesPerCore) # Parameters to set for each run: # Level 1: nL1ExcitNeurons = int(sys.argv[1]) # was 2400 nL2ExcitNeurons = int(sys.argv[2]) # was 2400 L1MeanWeightX2X = float(sys.argv[3]) L1MeanWeightX2I = float(sys.argv[3]) # Common: StdDev = 1.0 noiseRate = 9 # Hz print "Spike sources: ", nL1ExcitNeurons rng = NumpyRNG(seed=1) E2EmeanDelay = 7.0
import pylab from pacman.model.constraints.placer_constraints.placer_chip_and_core_constraint import PlacerChipAndCoreConstraint try: import pyNN.spiNNaker as sim except Exception as e: import spynnaker.pyNN as sim # SpiNNaker setup sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0) sim.set_number_of_neurons_per_core("IF_curr_exp", 50) # Population parameters model = sim.IF_curr_exp n_atoms = 25 cell_params = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } # Define layers
import pyNN.spiNNaker as p import numpy, pylab, random, sys import time import datetime as dt from math import * # import defined retina Functions from another python file from retinaFunc import * #Define Simulation Paras runtime = 10000 # just for gesture single num_per_core = 256 #INIT pacman103 p.setup(timestep=1.0, min_delay = 1.0, max_delay = 32.0) p.set_number_of_neurons_per_core('IF_curr_exp', num_per_core) # this will set one population per core #external stuff: population requiremenets connected_chip_coords = {'x': 0, 'y': 0} virtual_chip_coords = {'x': 0, 'y': 5} link = 4 integrate_size = 36 #spikeTrains, source_Num = load_inputSpikes3('recorded_data_for_spinnaker/integrate_all.mat', 'integrate', integrate_size) spikeTrains, source_Num = load_inputSpikes4('recorded_data_for_spinnaker/integrate_all.mat', 'integrate', integrate_size, runtime) ''' integrate_pop = [] print "source_Num:", source_Num for i in range(source_Num): #for i in range(1): pop = p.Population(integrate_size * integrate_size, p.SpikeSourceArray, {'spike_times': spikeTrains[i] }, label='retina_pop')
import pyNN.spiNNaker as p import retina_lib input_size = 128 # Size of each population subsample_size = 32 runtime = 60 # Simulation Setup p.setup(timestep=1.0, min_delay = 1.0, max_delay = 11.0) # Will add some extra parameters for the spinnPredef.ini in here p.set_number_of_neurons_per_core('IF_curr_exp', 128) # this will set one population per core cell_params = { 'tau_m' : 64, 'i_offset' : 0, 'v_rest' : -75, 'v_reset' : -95, 'v_thresh' : -40, 'tau_syn_E' : 15, 'tau_syn_I' : 15, 'tau_refrac' : 2} #external stuff population requiremenets connected_chip_coords = {'x': 0, 'y': 0} virtual_chip_coords = {'x': 0, 'y': 5} link = 4 print "Creating input population: %d x %d" % (input_size, input_size) input_pol_1_up = p.Population(128*128, p.ExternalRetinaDevice, {'virtual_chip_coords': virtual_chip_coords, 'connected_chip_coords':connected_chip_coords, 'connected_chip_edge':link, 'unique_id': 'R',
""" Synfirechain-like example """ import pyNN.spiNNaker as p import pylab p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core("IZK_curr_exp", 100) nNeurons = 200 # number of neurons in each population cell_params_izk = {'a': 0.02, 'b': 0.2, 'c': -65, 'd': 8, 'v_init': -75, 'u_init': 0, 'tau_syn_E': 2, 'tau_syn_I': 2, 'i_offset': 0 } populations = list() projections = list() weight_to_spike = 40 delay = 1 loopConnections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
import pyNN.spiNNaker as p import retina_lib input_size = 128 # Size of each population subsample_size = 32 runtime = 60 # Simulation Setup p.setup(timestep=1.0, min_delay=1.0, max_delay=11.0) # Will add some extra parameters for the spinnPredef.ini in here p.set_number_of_neurons_per_core("IF_curr_exp", 128) # this will set one population per core cell_params = { "tau_m": 64, "i_offset": 0, "v_rest": -75, "v_reset": -95, "v_thresh": -40, "tau_syn_E": 15, "tau_syn_I": 15, "tau_refrac": 2, } # external stuff population requiremenets connected_chip_coords = {"x": 0, "y": 0} virtual_chip_coords = {"x": 0, "y": 5} link = 4 print "Creating input population: %d x %d" % (input_size, input_size)
} inj_cell_params = { 'port': 12345, } inj_cell_type = ExternalDevices.SpikeInjector #~ num_inh = int(num_neurons*(1./4.)) rngseed = int(time.time()) #rngseed = 1 rng = sim.NumpyRNG(seed=rngseed) neuron_model = sim.IZK_curr_exp sim.set_number_of_neurons_per_core(neuron_model, 128) sim.setup(timestep=timestep, min_delay = min_delay, max_delay = max_delay) ############ stdp stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule(tau_plus=20., tau_minus=20.0, nearest=True), weight_dependence=sim.AdditiveWeightDependence(w_min=0.01, w_max=6., A_plus=0.02, A_minus=0.02) ) ############ random dist objects exc_delay_dist = RandomDistribution(distribution='uniform', parameters=[0,20.], rng=rng)
def lancement_sim(cellSourceSpikes, path, weight_input=0, weight_inter=0, max_time=800000, TIME_STEP=TIME_STEP, input_n=input_n, nb_neuron_int=nb_neuron_int, nb_neuron_out=nb_neuron_out, delay=delay, p_conn_in_int=p_conn_in_int, p_conn_int_out=p_conn_int_out, v_tresh=v_tresh): simulator = 'spinnaker' # le max_delay doit être inférieur à 14*time_step sim.setup(timestep=TIME_STEP, min_delay=delay, max_delay=delay * 2) randoms = np.random.rand(100, 1) #defining network topology lif_curr_exp_params = { 'cm': 1.0, # The capacitance of the LIF neuron in nano-Farads 'tau_m': 20.0, # The time-constant of the RC circuit, in milliseconds 'tau_refrac': 5.0, # The refractory period, in milliseconds 'v_reset': -65.0, # The voltage to set the neuron at immediately after a spike 'v_rest': -65.0, # The ambient rest voltage of the neuron 'v_thresh': -(v_tresh), # The threshold voltage at which the neuron will spike 'tau_syn_E': 5.0, # The excitatory input current decay time-constant 'tau_syn_I': 5.0, # The inhibitory input current decay time-constant 'i_offset': 0.0, # A base input current to add each timestep } # Population d'entrée avec comme source le SpikeSourceArray en paramètre Input = sim.Population(input_n, sim.SpikeSourceArray(spike_times=cellSourceSpikes), label="Input") Input.record("spikes") # Définition des types de neurones et des couches intermédiaire, de sortie, ainsi que celle contenant le neurone de l'attention LIF_Intermediate = sim.IF_curr_exp(**lif_curr_exp_params) Intermediate = sim.Population(nb_neuron_int, LIF_Intermediate, label="Intermediate") Intermediate.record(("spikes", "v")) LIF_Output = sim.IF_curr_exp(**lif_curr_exp_params) Output = sim.Population(nb_neuron_out, LIF_Output, label="Output") Output.record(("spikes", "v")) LIF_delayer = sim.IF_curr_exp(**lif_curr_exp_params) Delay_n = sim.Population(1, LIF_delayer, label="Delay") Delay_n.record(("spikes", "v")) # set the stdp mechanisim parameters, we are going to use stdp in both connections between (input-intermediate) adn (intermediate-output) python_rng = NumpyRNG(seed=98497627) delay = delay # (ms) synaptic time delay #A_minus # définition des connexions entre couches de neurones entrée <=> intermédiaire, intermédiaire <=> sortie # vérificatio pour savoir si on est dans le cas de la première simulation par défault ou si on doit injecter les poids if ((weight_input != 0) or (weight_inter != 0)): # cas ou l'on inject les poids Conn_input_inter = sim.Projection( Input, Intermediate, # Le fromListConnector pour injecter les poids connector=sim.FromListConnector(weight_input), receptor_type="excitatory", label="Connection input to intermediate", # des synapses static pour "suprimer" l'apprentissage synapse_type=sim.StaticSynapse()) Conn_inter_output = sim.Projection( Intermediate, Output, # pre and post population connector=sim.FromListConnector(weight_inter), receptor_type="excitatory", label="Connection intermediate to output", synapse_type=sim.StaticSynapse()) else: # cas par défault Conn_input_inter = sim.Projection( Input, Intermediate, connector=sim.FixedProbabilityConnector( p_conn_in_int, allow_self_connections=False), synapse_type=sim.StaticSynapse( weight=RandomDistribution('normal', (3, 2.9), rng=python_rng)), receptor_type="excitatory", label="Connection input to intermediate") Conn_inter_output = sim.Projection( Intermediate, Output, # pre and post population connector=sim.FixedProbabilityConnector( p_conn_int_out, allow_self_connections=False), synapse_type=sim.StaticSynapse( weight=RandomDistribution('normal', (3, 2.9), rng=python_rng)), receptor_type="excitatory", label="Connection intermediate to output") # définition des connexions inhibitrices des couches intermédiaire et de sortie FixedInhibitory_WTA = sim.StaticSynapse(weight=6) WTA_INT = sim.Projection( Intermediate, Intermediate, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_WTA, receptor_type="inhibitory", label="Connection WTA") WTA_OUT = sim.Projection( Output, Output, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_WTA, receptor_type="inhibitory", label="Connection WTA") # Connexion avec le neurone de l'attention FixedInhibitory_delayer = sim.StaticSynapse(weight=2) Delay_out = sim.Projection( Delay_n, Output, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_delayer, receptor_type="inhibitory", label="Connection WTA") Delay_inter = sim.Projection( Intermediate, Delay_n, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_delayer, receptor_type="inhibitory", label="Connection WTA") # On précise le nombre de neurone par coeurs au cas ou sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 255) # on arrondie le temps de simulation, sinon avec les callbacks, on a une boucle infinie pour des temps d'arrêts plus précis que la fréquence des callbacks simtime = ceil(max_time) try: #lancement de la simulation sim.run(simtime) #récupération des infos sur les spike des trois couches neo = Output.get_data(variables=["spikes", "v"]) spikes = neo.segments[0].spiketrains #print(spikes) v = neo.segments[0].filter(name='v')[0] neo_in = Input.get_data(variables=["spikes"]) spikes_in = neo_in.segments[0].spiketrains #print(spikes_in) neo_intermediate = Intermediate.get_data(variables=["spikes", "v"]) spikes_intermediate = neo_intermediate.segments[0].spiketrains #print(spikes_intermediate) v_intermediate = neo_intermediate.segments[0].filter(name='v')[0] #print(v_intermediate) sim.reset() sim.end() except: # Si la simulation fail, on set ces deux variables à zéros pour gérer l'erreur dans le script principal v = 0 spikes = 0 # Création et sauvegarde des graphs des graphs si la simluation s'est bien passée, + envoie des sorties de la fonction if (isinstance(spikes, list) and isinstance(v, AnalogSignal)): plot.Figure( # plot voltage for first ([0]) neuron plot.Panel(v, ylabel="Membrane potential (mV)", data_labels=[Output.label], yticks=True, xlim=(0, simtime)), # plot spikes (or in this case spike) plot.Panel(spikes, yticks=True, markersize=5, xlim=(0, simtime)), title="Spiking activity of the output layer during test", annotations="Simulated with {}".format(sim.name())).save( "./Generated_data/tests/" + path + "/output_layer_membrane_voltage_and_spikes.png") plot.Figure( # plot voltage for first ([0]) neuron plot.Panel(v_intermediate, ylabel="Membrane potential (mV)", data_labels=[Output.label], yticks=True, xlim=(0, simtime)), # plot spikes (or in this case spike) plot.Panel(spikes_intermediate, yticks=True, markersize=5, xlim=(0, simtime)), title="Spiking activity of the intermediate layer during test", annotations="Simulated with {}".format(sim.name())).save( "./Generated_data/tests/" + path + "/intermediate_layer_membrane_voltage_and_spikes.png") return v, spikes else: print( "simulation failed with parameters : (l'affichage des paramètres ayant causés le disfonctionnement de la simulation sera traitée à une date ultérieur, merci!)" ) return 0, 0
""" Synfirechain-like example """ import pyNN.spiNNaker as p import pylab import numpy 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):
import matplotlib.gridspec as gs import os #import pyNN.nest as pynn import pyNN.spiNNaker as pynn #set sim parameters sim_time = 150 dt = 0.1 refrac = 0 start_test=78 end_test= 84 print("trials from "+str(start_test)+ "to "+str(end_test) pynn.setup(dt) pynn.set_number_of_neurons_per_core(pynn.IF_curr_exp, 64) weight_scale = 1 rescale_fac = 1000/(1000*dt) #load data test_data = np.load("x_test.npz")['arr_0'][start_test:end_test] test_labels = np.load("y_test.npz")['arr_0'][start_test:end_test] pred_labels = [] #create network network = [] #cell defaults cell_params = {
def run_sim(self): """ Sets up and runs the simulation """ num_neurons = 1471 # total neurons in network num_inputs = 14 # number of neurons considered inputs num_runs = 1 # number of times to loop the learning num_samples = 1 # number of samples to learn` sim_time = 1000.0 # time to run sim for` inhibitory_split = 0.2 connection_probability_factor = 0.02 plot_spikes = True save_figures = True show_figures = True sim_start_time = strftime("%Y-%m-%d_%H:%M") cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 10.0, 'tau_refrac': 2.0, 'tau_syn_E': 3.0, 'tau_syn_I': 3.0, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -50.0} # Create the 3d structure of the NeuCube based on the user's given structure file network_structure = NetworkStructure() network_structure.load_structure_file() network_structure.load_input_location_file() # Calculate the inter-neuron distance to be used in the small world connections network_structure.calculate_distances() # Generate two connection matrices for excitatory and inhibitory neurons based on your defined split network_structure.calculate_connection_matrix(inhibitory_split, connection_probability_factor) # Get these lists to be used when connecting the neurons later excitatory_connection_list = network_structure.get_excitatory_connection_list() inhibitory_connection_list = network_structure.get_inhibitory_connection_list() # Choose the correct neurons to connect them to, based on your a-priori knowledge of the data source -- eg, EEG # to 10-20 locations, fMRI to voxel locations, etc. input_neuron_indexes = network_structure.find_input_neurons() # Make the input connections based on this new list input_weight = 4.0 input_connection_list = [] for index, input_neuron_index in enumerate(input_neuron_indexes): input_connection_list.append((index, input_neuron_index, input_weight, 0)) for run_number in xrange(num_runs): excitatory_weights = [] inhibitory_weights = [] for sample_number in xrange(num_samples): # At the moment with the limitations of the SpiNNaker hardware we have to reinstantiate EVERYTHING # each run. In future there will be some form of repetition added, where the structure stays in memory # on the SpiNNaker and only the input spikes need to be updated. data_prefix = sim_start_time + "_r" + str(run_number + 1) + "-s" + str(sample_number + 1) # Set up the hardware - min_delay should never be less than the timestep. # Timestep should = 1.0 (ms) for normal realtime applications p.setup(timestep=1.0, min_delay=1.0) p.set_number_of_neurons_per_core("IF_curr_exp", 100) # Create a population of neurons for the reservoir neurons = p.Population(num_neurons, p.IF_curr_exp, cell_params_lif, label="Reservoir") # Setup excitatory STDP timing_rule_ex = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0) weight_rule_ex = p.AdditiveWeightDependence(w_min=0.1, w_max=1.0, A_plus=0.02, A_minus=0.02) stdp_model_ex = p.STDPMechanism(timing_dependence=timing_rule_ex, weight_dependence=weight_rule_ex) # Setup inhibitory STDP timing_rule_inh = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0) weight_rule_inh = p.AdditiveWeightDependence(w_min=0.0, w_max=0.6, A_plus=0.02, A_minus=0.02) stdp_model_inh = p.STDPMechanism(timing_dependence=timing_rule_inh, weight_dependence=weight_rule_inh) # record the spikes from that population neurons.record('spikes') # Generate a population of SpikeSourceArrays containing the encoded input spike data # eg. spike_sources = p.Population(14, p.SpikeSourceArray, {'spike_times': [[]]}) # for the moment I'm going to cheat and just use poisson trains as I don't have data with me spike_sources = p.Population(num_inputs, p.SpikeSourcePoisson, {'rate': rand.randint(20, 80)}, label="Poisson_pop_E") # Connect the input spike sources with the "input" neurons connected_inputs = p.Projection(spike_sources, neurons, p.FromListConnector(input_connection_list)) # If we have weights saved/recorded from a previous run of this network, load them into the structure # population.set(weights=weights_list) and population.setWeights(weight_list) are not supported in # SpiNNaker at the moment so we have to do this manually. if excitatory_weights and inhibitory_weights: for index, ex_connection in enumerate(excitatory_connection_list): ex_connection[2] = excitatory_weights[index] for index, in_connection in enumerate(inhibitory_connection_list): in_connection[2] = inhibitory_weights[index] # Setup the connectors excitatory_connector = p.FromListConnector(excitatory_connection_list) inhibitory_connector = p.FromListConnector(inhibitory_connection_list) # Connect the excitatory and inhibitory neuron populations connected_excitatory_neurons = p.Projection(neurons, neurons, excitatory_connector, synapse_dynamics=p.SynapseDynamics(slow=stdp_model_ex), target="excitatory") connected_inhibitory_neurons = p.Projection(neurons, neurons, inhibitory_connector, synapse_dynamics=p.SynapseDynamics(slow=stdp_model_inh), target="inhibitory") # Set up recording the spike trains of all the neurons neurons.record() spike_sources.record() # Run the actual simulation p.run(sim_time) # Save the output spikes spikes_out = neurons.getSpikes(compatible_output=True) input_spikes_out = spike_sources.getSpikes(compatible_output=True) # Get the synaptic weights of all the neurons excitatory_weights = connected_excitatory_neurons.getWeights() inhibitory_weights = connected_inhibitory_neurons.getWeights() # when we're all done, clean up p.end() # Make some plots, save them if required. Check if you need to either save or show them, because if not, # there's no point wasting time plotting things nobody will ever see. if plot_spikes and (save_figures or show_figures): plot = Plot(save_figures, data_prefix) # Plot the 3D structure of the network plot.plot_structure(network_structure.get_positions(), figure_number=0) # Plot the spikes plot.plot_spike_raster(spikes_out, sim_time, num_neurons, figure_number=1) # Plot the weights plot.plot_both_weights(excitatory_weights, inhibitory_weights, figure_number=2) # If we want to show the figures, show them now, otherwise ignore and move on if show_figures: # Show them all at once plot.show_plots() plot.clear_figures() plot = None
def lancement_sim(cellSourceSpikes, max_time=800000, path="default", TIME_STEP=TIME_STEP, input_n=input_n, nb_neuron_int=nb_neuron_int, nb_neuron_out=nb_neuron_out, delay=delay, p_conn_in_int=p_conn_in_int, p_conn_int_out=p_conn_int_out, a_minus=0.6, a_plus=0.6, tau_minus=12.0, tau_plus=10.0, v_tresh=10.0): simulator = 'spinnaker' sim.setup(timestep=TIME_STEP, min_delay=delay, max_delay=delay * 2) randoms = np.random.rand(100, 1) lif_curr_exp_params = { 'cm': 1.0, # The capacitance of the LIF neuron in nano-Farads 'tau_m': 20.0, # The time-constant of the RC circuit, in milliseconds 'tau_refrac': 5.0, # The refractory period, in milliseconds 'v_reset': -65.0, # The voltage to set the neuron at immediately after a spike 'v_rest': -65.0, # The ambient rest voltage of the neuron 'v_thresh': -(v_tresh), # The threshold voltage at which the neuron will spike 'tau_syn_E': 5.0, # The excitatory input current decay time-constant 'tau_syn_I': 5.0, # The inhibitory input current decay time-constant 'i_offset': 0.0, # A base input current to add each timestep } Input = sim.Population(input_n, sim.SpikeSourceArray(spike_times=cellSourceSpikes), label="Input") Input.record("spikes") LIF_Intermediate = sim.IF_curr_exp(**lif_curr_exp_params) Intermediate = sim.Population(nb_neuron_int, LIF_Intermediate, label="Intermediate") Intermediate.record(("spikes", "v")) LIF_Output = sim.IF_curr_exp(**lif_curr_exp_params) Output = sim.Population(nb_neuron_out, LIF_Output, label="Output") Output.record(("spikes", "v")) LIF_delayer = sim.IF_curr_exp(**lif_curr_exp_params) Delay_n = sim.Population(1, LIF_delayer, label="Delay") Delay_n.record(("spikes", "v")) python_rng = NumpyRNG(seed=98497627) delay = delay # (ms) synaptic time delay # Définition du fonctionnement de la stdp stdp_proj = sim.STDPMechanism( 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.1, w_max=6), weight=RandomDistribution('normal', (3, 2.9), rng=python_rng), delay=delay) Conn_input_inter = sim.Projection( Input, Intermediate, connector=sim.FixedProbabilityConnector(p_conn_in_int, allow_self_connections=False), # synapse type set avec la définition de la stdp pour l'aprentsissage synapse_type=stdp_proj, receptor_type="excitatory", label="Connection input to intermediate") # second projection with stdp Conn_inter_output = sim.Projection( Intermediate, Output, # pre and post population connector=sim.FixedProbabilityConnector(p_conn_int_out, allow_self_connections=False), synapse_type=stdp_proj, receptor_type="excitatory", label="Connection intermediate to output") FixedInhibitory_WTA = sim.StaticSynapse(weight=6) WTA_INT = sim.Projection( Intermediate, Intermediate, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_WTA, receptor_type="inhibitory", label="Connection WTA") WTA_OUT = sim.Projection( Output, Output, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_WTA, receptor_type="inhibitory", label="Connection WTA") FixedInhibitory_delayer = sim.StaticSynapse(weight=2) Delay_out = sim.Projection( Delay_n, Output, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_delayer, receptor_type="inhibitory", label="Connection WTA") Delay_inter = sim.Projection( Intermediate, Delay_n, connector=sim.AllToAllConnector(allow_self_connections=False), synapse_type=FixedInhibitory_delayer, receptor_type="inhibitory", label="Connection WTA") sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 255) # Définition des callbacks pour la récupération de l'écart-type sur les connexions entrée-intermédiaire, intermédiaire-sortie weight_recorder1 = WeightRecorder(sampling_interval=1000.0, projection=Conn_input_inter) weight_recorder2 = WeightRecorder(sampling_interval=1000.0, projection=Conn_inter_output) simtime = ceil(max_time) # Initialisation des tableaux pour la récupération des poids weights_int = [] weights_out = [] try: sim.run(simtime, callbacks=[weight_recorder1, weight_recorder2]) neo = Output.get_data(variables=["spikes", "v"]) spikes = neo.segments[0].spiketrains #print(spikes) v = neo.segments[0].filter(name='v')[0] weights_int = Conn_input_inter.get(["weight"], format="list") neo_in = Input.get_data(variables=["spikes"]) spikes_in = neo_in.segments[0].spiketrains #print(spikes_in) neo_intermediate = Intermediate.get_data(variables=["spikes", "v"]) spikes_intermediate = neo_intermediate.segments[0].spiketrains #print(spikes_intermediate) v_intermediate = neo_intermediate.segments[0].filter(name='v')[0] #print(v_intermediate) weights_out = Conn_inter_output.get(["weight"], format="list") sim.reset() sim.end() except: v = 0 spikes = 0 if (isinstance(spikes, list) and isinstance(v, AnalogSignal)): # Récupération des écart-types standard_deviation_out = weight_recorder2.get_standard_deviations() standard_deviation_int = weight_recorder1.get_standard_deviations() t = np.arange(0., max_time, 1.) # Création et sauvegarde des graphs sur les spikes et écart-types savePath = "./Generated_data/training/" + path + "/intermediate_layer_standard_deviation.png" plt.plot(standard_deviation_int) plt.xlabel("callbacks tick (1s)") plt.ylabel("standard deviation of the weights( wmax=6, wmin=0.1 )") plt.savefig(savePath) plt.clf() savePath = "./Generated_data/training/" + path + "/output_layer_standard_deviation.png" plt.plot(standard_deviation_out) plt.xlabel("callbacks tick") plt.ylabel("standard deviation ( wmax=6, wmin=0.1 )") plt.savefig(savePath) plt.clf() savePath = "./Generated_data/training/" + path + "/output_layer_membrane_voltage_and_spikes.png" plot.Figure( # plot voltage for first ([0]) neuron plot.Panel(v, ylabel="Membrane potential (mV)", data_labels=[Output.label], yticks=True, xlim=(0, simtime)), # plot spikes (or in this case spike) plot.Panel(spikes, yticks=True, markersize=5, xlim=(0, simtime)), title="Spiking activity of the output layer during training", annotations="Simulated with {}".format(sim.name())).save(savePath) savePath = "./Generated_data/training/" + path + "/intermediate_layer_membrane_voltage_and_spikes.png" plot.Figure( # plot voltage for first ([0]) neuron plot.Panel(v_intermediate, ylabel="Membrane potential (mV)", data_labels=[Output.label], yticks=True, xlim=(0, simtime)), # plot spikes (or in this case spike) plot.Panel(spikes_intermediate, yticks=True, markersize=5, xlim=(0, simtime)), title="Spiking activity of the intermediate layer during training", annotations="Simulated with {}".format(sim.name())).save(savePath) return v, spikes, weights_int, weights_out else: print( "simulation failed with parmaters parameters : (l'affichage des paramètres ayant causés le disfonctionnement de la simulation sera traitée à une date ultérieur, merci!)" ) return 0, 0, 0, 0