def connectClusterPNtoAN(params,popClusterPN,popClusterAN, observationExposureTimeMs, projLabel=''): #Using custom Hebbian-style plasticity, connect neurons in specfied PN cluster to x% neurons in specified AN cluster startWeightPNAN = float(params['STARTING_WEIGHT_PN_AN']) delayPNAN = int(params['DELAY_PN_AN']) connectivity = float(params['CONNECTIVITY_PN_AN']) #STDP curve parameters tau = float(params['STDP_TAU_PN_AN']) wMin = float(params['STDP_WMIN_PN_AN']) wMax = float(params['STDP_WMAX_PN_AN']) gainScaling = float(params['STDP_SCALING_PN_AN']) ''' #this setting was tuned for a 120ms learning window #rescale it according to actual window used. ie for longer window, slow down learning rate tweak = 120.0/float(observationExposureTimeMs) gainScaling = gainScaling * tweak print "Weight gain scaled by factor of ", tweak ''' timingDependence = spynnaker.SpikePairRule(tau_plus=tau, tau_minus=tau, nearest=True) weightDependence = spynnaker.AdditiveWeightDependence(w_min=wMin, w_max=wMax, A_plus=gainScaling, A_minus=-gainScaling) stdp_model = spynnaker.STDPMechanism(timing_dependence = timingDependence, weight_dependence = weightDependence) probConnector = spynnaker.FixedProbabilityConnector(connectivity, weights=startWeightPNAN, delays=delayPNAN, allow_self_connections=True) projClusterPNToClusterAN = spynnaker.Projection(popClusterPN, popClusterAN,probConnector,synapse_dynamics = spynnaker.SynapseDynamics(slow = stdp_model), target='excitatory', label=projLabel) return projClusterPNToClusterAN
def createInterPopulationWTA(populations, weight, delay, connectivity): probConnector = spynnaker.FixedProbabilityConnector( connectivity, weights=weight, delays=delay, allow_self_connections=True) for i in range(len(populations)): for j in range(len(populations)): if i != j: projInhibitory = spynnaker.Projection(populations[i], populations[j], probConnector, target='inhibitory')
def connectClusterPNtoAN(params,popClusterPN,popClusterAN, projLabel=''): #Using custom Hebbian-style plasticity, connect neurons in specfied PN cluster to x% neurons in specified AN cluster startWeightPNAN = float(params['STARTING_WEIGHT_PN_AN']) delayPNAN = int(params['DELAY_PN_AN']) connectivity = float(params['CONNECTIVITY_PN_AN']) #STDP curve parameters tau = float(params['STDP_TAU_PN_AN']) wMin = float(params['STDP_WMIN_PN_AN']) wMax = float(params['STDP_WMAX_PN_AN']) gainScaling = float(params['STDP_SCALING_PN_AN']) timingDependence = spynnaker.SpikePairRule(tau_plus=tau, tau_minus=tau, nearest=True) weightDependence = spynnaker.AdditiveWeightDependence(w_min=wMin, w_max=wMax, A_plus=gainScaling, A_minus=-gainScaling) stdp_model = spynnaker.STDPMechanism(timing_dependence = timingDependence, weight_dependence = weightDependence) probConnector = spynnaker.FixedProbabilityConnector(connectivity, weights=startWeightPNAN, delays=delayPNAN, allow_self_connections=True) projClusterPNToClusterAN = spynnaker.Projection(popClusterPN, popClusterAN,probConnector,synapse_dynamics = spynnaker.SynapseDynamics(slow = stdp_model), target='excitatory', label=projLabel) return projClusterPNToClusterAN
def createInterPopulationWTA(populations, weight, delay, connectivity): probConnector = spynnaker.FixedProbabilityConnector( connectivity, weights=weight, delays=delay, allow_self_connections=True) numPopulations = len(populations) if numPopulations > 1: popCreatedCount = 0 totalProjections = numPopulations * (numPopulations - 1) for i in range(numPopulations): for j in range(numPopulations): if i != j: projInhibitory = spynnaker.Projection(populations[i], populations[j], probConnector, target='inhibitory') popCreatedCount = popCreatedCount + 1 print 'Created ', popCreatedCount, ' of ', totalProjections, ' (', 100 * float( popCreatedCount) / float(totalProjections), '%)' #print ' WTA connections', projInhibitory.getWeights() else: print 'No inter-projections created , only one population provided'
wdep_grcpcsynapsis = p.AdditiveWeightDependence(w_min=0.0, w_max=0.5, A_plus=0.0015, A_minus=0.0018) tdep_grcpcsynapsis = p.SpikePairRuleSinAdd(tau_minus=50., tau_plus=50., delay=100.0, nearest=False) # delay 70-100 stdp_grcpcsynapsis = p.STDPMechanism(timing_dependence=tdep_grcpcsynapsis, weight_dependence=wdep_grcpcsynapsis, voltage_dependence=None) syndyn_grcpcsynapsis = p.SynapseDynamics(slow=stdp_grcpcsynapsis) rng = p.NumpyRNG() grcpc_weights_distribution = p.RandomDistribution('uniform', [0.05, 0.5], rng) pro_grcpcsynapsis_connector = p.FixedProbabilityConnector( 0.8, weights=grcpc_weights_distribution) pro_grcpcsynapsis_left = p.Projection(prepop, postpop, pro_grcpcsynapsis_connector, target="excitatory", synapse_dynamics=syndyn_grcpcsynapsis, label="grcpcsynapsis") proj = pro_grcpcsynapsis_left proj.projection_edge.postvertex.custom_max_atoms_per_core = max( 1, 4000 / proj.projection_edge.prevertex.atoms) #plasticsyn.projection_edge.postvertex.custom_max_atoms_per_core = 100 p.run(duration) #IPython.embed()
def test_snn(randomness = False, data_dir = "data/X_test_zied.npy", cls_dir = "data/y_test_zied.npy", data = "load", # pass data as argument cls = "load"): # pass labels as argument ############################################################################### ## Function Definitions ############################################################################### def gaussian(x, mu, sig): return np.float16(np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))) def calc_pop_code(feature, rng1, rng2, num): interval = np.float(rng2 - rng1) / num means = np.arange(rng1 + interval,rng2 + interval, interval) pop_code = [gaussian(feature, mu, 0.025) for mu in means] return pop_code def PoissonTimes2(t_str=0., t_end=100., rate=10., seed=1.): times = [t_str] rng = np.random.RandomState(seed=seed) cont = True while cont == True: t_next = np.floor(times[-1] + 1000. * next_spike_times(rng, rate)) if t_next < t_end - 30: times.append(t_next[0]) else: cont = False return times[1:] def PoissonTimes(t_str=0., t_end=100., rate=10., seed=1.): if rate > 0: interval = (t_end - t_str+0.) / rate times = np.arange(t_str + 30, t_end - 40, interval) return list(times) else: return [] def next_spike_times(rng,rate): return -np.log(1.0 - rng.rand(1)) / rate def ismember(a, b): b = [b] bind = {} for i, elt in enumerate(b): if elt not in bind: bind[elt] = i aa=[bind.get(itm, -1) for itm in a] return sum(np.array(aa) + 1.) ############################################################################### ## Parameters ############################################################################### # Load Parameter parameters = np.load("output_files/parameters1.npy") parameters = parameters.item() # Load test data if data == "load" and cls == "load": data = np.load(data_dir) cls = np.load(cls_dir) # Simulation Parameters trial_num = parameters["trial_num"] # How many samples (trials) from data will be presented n_trials = len(cls)#10#20 #int(trial_num) # Total trials time_int_trials = parameters["time_int_trials"] # (ms) Time to present each trial data SIM_TIME = n_trials * time_int_trials # Total simulation time (ms) ts = parameters["ts"] # Timestep of Spinnaker (ms) min_del = ts max_del = 144 * ts p.setup(timestep=ts, min_delay=min_del, max_delay=max_del) ## Neuron Numbers n_feature = parameters["n_feature"] # Number of features n_pop = parameters["n_pop"] # Number of neurons in one population n_cl = parameters["n_cl"] # Number of classes at the output ## Connection Parameters # Weights wei_src_enc = parameters["wei_src_enc"] # From Source Array at input to Encoding Layer(Exc) wei_enc_filt = parameters["wei_enc_filt"] # From Encoding Layer to Filtering Layer Exc neurons (Exc) wei_filt_inh = parameters["wei_filt_inh"] # From Filtering Layer Inh neurons to Exc neurons (Inh) wei_cls_exc = parameters["wei_cls_exc"] # From Output Layer Exc neurons to Inh neurons (Exc) wei_cls_inh = parameters["wei_cls_inh"] # From Output Layer Inh neurons to Exc neurons (Inh) wei_noise_poi = parameters["wei_noise_poi"] # Delays del_src_enc = np.load("output_files/parameters2.npy") del_enc_filt = parameters["del_enc_filt"] del_init_stdp = parameters["del_init_stdp"] del_cls_exc = parameters["del_cls_exc"] del_cls_inh = parameters["del_cls_inh"] del_noise_poi = parameters["del_noise_poi"] # Firing Rates noise_poi_rate = parameters["noise_poi_rate"] max_fr_input = parameters["max_fr_input"] # maximum firing rate at the input layer max_fr_rate_output = parameters["max_fr_rate_output"] # Maximum firing rate at output (supervisory signal) ## Connection Probabilities prob_filt_inh = parameters["prob_filt_inh"] # Prob of connectivity inhi-connections at Filtering Layer prob_stdp = parameters["prob_stdp"] # Probability of STDP connections prob_output_inh = parameters["prob_output_inh"] # Prob of inhi-connections at Output Layer prob_noise_poi_conn = parameters["prob_noise_poi_conn"] ## STDP Parameters tau_pl = parameters["tau_pl"] #5 tau_min = tau_pl stdp_w_max = parameters["stdp_w_max"] stdp_w_min = parameters["stdp_w_min"] stdp_A_pl = parameters["stdp_A_pl"] stdp_A_min = -stdp_A_pl # minus in order to get symmetric curve ## Neuron Parameters cell_params_lif = {'cm': 1., 'i_offset': 0.0, 'tau_m': 20., 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -65.0 } ############################################################################### ## Data Extraction ############################################################################### ## Extract Feature Data scale_data = parameters["scale_data"] # Scale features into [0-scale_data] range #data = np.load("features_without_artifact.npy") #data = np.load('X_test.npy') r, c = np.shape(data) # Threshold (to keep spikes amplitudes in range) thr_data_plus = parameters["thr_data_plus"] thr_data_minus = parameters["thr_data_minus"] data_rates = np.reshape(data, (1, r * c))[0] # Shift an normalize the data #dd = [d if d<thr_data_plus else thr_data_plus for d in data_rates] #dd = [d if d>thr_data_minus else thr_data_minus for d in dd] #dd2 = np.array(dd) - min(dd) #dd2 = dd2 / max(dd2) * 2 dd2 = np.array(data_rates) - min(data_rates) dd2 = dd2 / max(dd2) * 2 new_data_rates = [] for r in dd2: new_data_rates += calc_pop_code(r, 0., scale_data, n_feature / (n_pop + 0.0)) data_rates = list(max_fr_input * np.array(new_data_rates)) ## Extract Class Data #cls = np.load("classes_without_artifact.npy") #cls = np.load("y_test.npy") cls = cls.reshape(len(cls), 1) r_cl, c_cl = np.shape(cls) cls = list(np.reshape(cls, (1, r_cl * c_cl))[0]) outputs = cls[:n_trials] poi_rate = data_rates[:n_feature * n_trials] t1 = 0#70 t2 = int(t1 + n_trials) outputs = cls[t1:t2] poi_rate = data_rates[t1 * n_feature:n_feature * t2] ############################################################################### ## Create populations for different layers ############################################################################### poi_layer = [] enc_layer = [] filt_layer_exc = [] out_layer_exc = [] out_layer_inh = [] # Calculate poisson spike times for features spike_times = [[] for i in range(n_feature)] for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials ind = i * n_feature for j in range(n_feature): times = PoissonTimes(t_st, t_end, poi_rate[ind+j], np.random.randint(100)) for t in times: spike_times[j].append(t) if randomness == True: # if True: calculate "spike_times" (randomly) new # if False: load previously saved "spike_times" np.save('output_files/spike_times_test.npy', spike_times) else: spike_times = np.load('output_files/spike_times_test.npy') # Spike source of input layer spike_source = p.Population(n_feature, p.SpikeSourceArray, {'spike_times':spike_times}, label='spike_source') enc_layer = p.Population(n_feature * n_pop, p.IF_curr_exp, cell_params_lif, label='enc_layer') filt_layer = p.Population(n_feature * n_pop, p.IF_curr_exp, cell_params_lif, label='filt_layer') #filt_layer_inh=p.Population(n_feature*n_pop, p.IF_curr_exp, cell_params_lif, label='filt_layer_inh') for i in range(n_cl): out_layer_exc.append(p.Population(n_pop, p.IF_curr_exp, cell_params_lif, label='out_layer_exc{}'.format(i))) out_layer_inh.append(p.Population(n_pop, p.IF_curr_exp, cell_params_lif, label='out_layer_inh{}'.format(i))) out_layer_exc[i].record() poisson_input = p.Population(n_pop * 2, p.SpikeSourcePoisson, {"rate":noise_poi_rate}) enc_layer.record() filt_layer.record() ############################################################################### ## Projections ############################################################################### ## Connection List from Spike Source Array to Encoding Layer conn_inp_enc = np.load("output_files/conn_inp_enc.npy") #Connection List for Filtering Layer Inhibitory conn_filt_inh = np.load("output_files/conn_filt_inh.npy") ## STDP Connection List conn_stdp_list = np.load("output_files/conn_stdp_list.npy") diff_ind = np.load("output_files/diff_ind_filt.npy") diff_ind2 = np.load("output_files/diff_ind_filt2.npy") diff_thr2 = np.load("output_files/diff_thr2.npy") c1 = 0 for cls_list in conn_stdp_list: c2 = 0 cls_wei = np.load("output_files/stdp_weights{}.npy".format(c1)) mx = max(cls_wei) for conn in cls_list: # if ismember(diff_ind,conn[0]): if (ismember(diff_ind2,conn[0]) and np.sign(c1-0.5) * np.sign(diff_thr2[int(conn[0])]) == -1.): # conn[2]=0.08*cls_wei[c2]/mx conn[2] = 0.08#*diff_thr2[conn[0]]/36. # conn[2]=2.*cls_wei[c2] c2 += 1 c1 += 1 conn_stdp_list = list(conn_stdp_list) ## Output Layer Inhibitory Connection List conn_output_inh = np.load("output_files/conn_output_inh.npy") ## Spike Source to Encoding Layer p.Projection(spike_source,enc_layer,p.FromListConnector(conn_inp_enc)) ## Encoding Layer to Filtering Layer p.Projection(enc_layer, filt_layer, p.OneToOneConnector(weights=wei_enc_filt, delays=del_enc_filt)) ## Filtering Layer Inhibitory p.Projection(filt_layer,filt_layer, p.FromListConnector(conn_filt_inh), target="inhibitory") ## STDP Connection between Filtering Layer and Output Layer stdp_proj = [] for j in range(n_cl): stdp_proj.append(p.Projection(filt_layer, out_layer_exc[j], p.FromListConnector(conn_stdp_list[j]))) ## Connection between Output Layer neurons c = 0 for i in range(n_cl): p.Projection(out_layer_exc[i], out_layer_inh[i], p.OneToOneConnector(weights=wei_cls_exc, delays=del_cls_exc)) iter_array = [j for j in range(n_cl) if j != i] for j in iter_array: p.Projection(out_layer_inh[i], out_layer_exc[j], p.FromListConnector(conn_output_inh[c]), target="inhibitory") c+=1 ## Noisy poisson connection to encoding layer if randomness == True: # if True: connect noise to network # if False: don't use noise in network p.Projection(poisson_input, enc_layer, p.FixedProbabilityConnector(p_connect=prob_noise_poi_conn, weights=wei_noise_poi, delays = del_noise_poi)) ############################################################################### ## Simulation ############################################################################### p.run(SIM_TIME) Enc_Spikes = enc_layer.getSpikes() Filt_Exc_Spikes = filt_layer.getSpikes() #Filt_Inh_Spikes = filt_layer_inh.getSpikes() Out_Spikes = [[] for i in range(n_cl)] for i in range(n_cl): Out_Spikes[i] = out_layer_exc[i].getSpikes() p.end() ############################################################################### ## Plot ############################################################################### ## Plot 1 if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Encoding Layer Raster Plot') pylab.hold(True) pylab.plot([i[1] for i in Enc_Spikes], [i[0] for i in Enc_Spikes], ".b") pylab.hold(False) #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 2-1 if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Filtering Layer Raster Plot') pylab.plot([i[1] for i in Filt_Exc_Spikes], [i[0] for i in Filt_Exc_Spikes], ".b") #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 2-2 pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Filtering Layer Raster Plot') pylab.hold(True) pylab.plot([i[1] for i in Filt_Exc_Spikes], [i[0] for i in Filt_Exc_Spikes], ".b") time_ind=[i*time_int_trials for i in range(len(outputs))] for i in range(len(time_ind)): pylab.plot([time_ind[i],time_ind[i]],[0,2000],"r") pylab.hold(False) #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 3-1 if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Association Layer Raster Plot\nTest for Trial Numbers {}-{}'.format(t1,t2)) pylab.hold(True) c=0 for array in Out_Spikes: pylab.plot([i[1] for i in array], [i[0]+c for i in array], ".b") c+=0.2 time_cls=[j*time_int_trials+i for j in range(len(outputs)) for i in range(int(time_int_trials))] cls_lb=[outputs[j]+0.4 for j in range(len(outputs)) for i in range(int(time_int_trials))] time_ind=[i*time_int_trials for i in range(len(outputs))] for i in range(len(time_ind)): pylab.plot([time_ind[i],time_ind[i]],[0,10],"r") #pylab.plot(time_cls,cls_lb,".") pylab.hold(False) pylab.axis([-10,SIM_TIME+100,-1,n_pop+2]) pylab.show() ## Plot 3-2 pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title(('Association Layer Raster Plot\n', 'Test for Samples {}-{}').format(t1,t2)) pylab.hold(True) pylab.plot([i[1] for i in Out_Spikes[0]], [i[0] for i in Out_Spikes[0]], ".b") pylab.plot([i[1] for i in Out_Spikes[1]], [i[0] + 0.2 for i in Out_Spikes[1]], ".r") time_ind = [i * time_int_trials for i in range(len(outputs))] for i in range(len(time_ind)): pylab.plot([time_ind[i], time_ind[i]], [0,n_pop], "k") #pylab.plot(time_cls,cls_lb,".") pylab.hold(False) pylab.axis([-10, SIM_TIME+100, -1, n_pop + 2]) pylab.legend(["AN1","AN2" ]) pylab.show() sum_output = [[] for i in range(n_cl)] for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials for j in range(n_cl): sum_output[j].append(np.sum( [1 for n, t in Out_Spikes[j] if t >= t_st and t < t_end]) ) ## Plot 4 if 0: # pylab.figure() # pylab.hold(True) # pylab.plot(sum_output[0], "b.") # pylab.plot(sum_output[1], "r.") # out_cl0 = [i for i in range(len(outputs)) if outputs[i] == 0] # out_cl1 = [i for i in range(len(outputs)) if outputs[i] == 1] # pylab.plot(out_cl0,[-2 for i in range(len(out_cl0))], "xb") # pylab.plot(out_cl1,[-2 for i in range(len(out_cl1))], "xr") # pylab.hold(False) # pylab.title("Total spikes at each AN population for each trial") # pylab.xlabel("Trials") # pylab.ylabel("Firing Rate") # pylab.legend(["Cl0","Cl1","Winning Cl 0", "Winning Cl 1"]) # pylab.axis([-2, n_trials + 2, -4, max(max(sum_output)) + 30]) # pylab.show() pylab.figure() pylab.hold(True) pylab.plot(sum_output[0], "b^") pylab.plot(sum_output[1], "r^") #pylab.plot(sum_output[0],"b") #pylab.plot(sum_output[1],"r") ppp0 = np.array(sum_output[0]) ppp1 = np.array(sum_output[1]) out_cl0 = [i for i in range(len(outputs)) if outputs[i] == 0] out_cl1 = [i for i in range(len(outputs)) if outputs[i] == 1] pylab.plot(out_cl0, ppp0[out_cl0], "bs") pylab.plot(out_cl1, ppp1[out_cl1], "rs") pylab.hold(False) pylab.title("Total spikes at each AN population for each trial") pylab.xlabel("Trials") pylab.ylabel("Spike Count for Each Trial") pylab.legend(["Cls 0", "Cls 1", "Actual Winner Cls 0", "Actual Winner Cls 1"]) pylab.axis([-2, n_trials + 2, -4, max(max(sum_output)) + 30]) pylab.show() ## Check Classification rate s = np.array(sum_output) cl = np.floor((np.sign(s[1] - s[0]) + 1) / 2) r_cl = np.array(outputs) wrong = np.sum(np.abs(cl - r_cl)) rate = (n_trials - wrong) / n_trials print("success rate: {}%".format(abs(rate)*100.)) print("cl:\n", cl) print("r_cl:\n", r_cl) ## Plot 5 if 0: pylab.figure() cf = 0.1 pylab.hold(True) cls_wei0 = np.load("output_files/stdp_weights{}.npy".format(0)) mx = max(cls_wei0) cls_wei0 = cf * cls_wei0 / mx cls_wei1 = np.load("output_files/stdp_weights{}.npy".format(1)) mx = max(cls_wei1) cls_wei1 = cf * cls_wei1/ mx l = min(len(cls_wei0), len(cls_wei1)) new_array0 = [cls_wei0[i] for i in range(l) if cls_wei0[i] > cls_wei1[i]] x0 = [i for i in range(l) if cls_wei0[i] > cls_wei1[i]] new_array1 = [cls_wei1[i] for i in range(l) if cls_wei1[i] > cls_wei0[i]] x1 = [i for i in range(l) if cls_wei1[i] > cls_wei0[i]] pylab.plot(x0, new_array0, "gx") pylab.plot(x1, new_array1, "bx") #for i in range(2): # cls_wei=np.load("stdp_weights{}.npy".format(i)) # mx=max(cls_wei) # cls_wei=0.05*cls_wei/mx # pylab.plot(cls_wei,"x") pylab.axis([-10, 2000, -0.1, 0.15]) pylab.hold(False) pylab.show() ## Plot 7 if 0: sum_filt = [[0 for i in range(n_feature * n_pop)] for j in range(n_cl)] sum_filt = np.array(sum_filt) for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials cl = outputs[i] for n, t in Filt_Exc_Spikes: if t >= t_st and t < t_end: sum_filt[int(cl),int(n)] = sum_filt[(cl),int(n)] + 1 a4=sum_filt[0] b4=sum_filt[1] pylab.figure() pylab.hold(True) pylab.plot(a4,"b.") pylab.plot(b4,"r.") pylab.xlabel('Neuron ID') pylab.ylabel('Total Firing Rates Through Trials') pylab.title("Total Spiking Activity of Neurons at Decomposition Layer for Each Class") pylab.hold(False) pylab.legend(["Activity to AN1","Activity to AN2"]) pylab.show() return rate
def train_snn(### Settings data_dir = "data/X_train_zied.npy", cls_dir = "data/y_train_zied.npy", data = "load", # pass data as argument cls = "load", # pass labels as argument save = True, # True to save all parameters of the network randomness = True, reverse_src_del = False, use_old_weights = False, rand_data = False, ### Parameters n_training = 2, # How many times the samples will be iterated ts = 1., # Timestep of Spinnaker (ms) trial_num = 10, # How many samples (trials) from data used # Network n_feature = 80, # Number of features (= 4 features * 20 neurons) # Weights wei_src_enc = .2, # From Source Array at input to Encoding Layer(Exc) wei_enc_filt = .6, # From Encoding Layer to Filtering Layer Exc neurons (Exc) wei_filt_inh = 0.03, # From Filtering Layer Inh neurons to Exc neurons (Inh) wei_init_stdp = .0, # From Filtering Layer Exc neurons to Output Layer (Exc) wei_cls_exc = 0.9, # From Output Layer Exc neurons to Inh neurons (Exc) wei_cls_inh = 50,#0.1,#,10 # From Output Layer Inh neurons to Exc neurons (Inh) wei_source_outp = 10., # From Source Array at output to Output Layer Exc neurons (Exc) wei_noise_poi = 0.02, # Delays del_init_stdp = 1., del_source_outp = 1., del_noise_poi = 1., # Connection Probabilities prob_filt_inh = .4, # Prob of connectivity inhibitory connections at FilT_Layer prob_stdp = 1., # Prob of STDP connections prob_output_inh = .7, # Prob of inhibitory connections at Output Layer prob_noise_poi_conn = 0.02, ## STDP Parameters tau_pl = 5., stdp_w_max = 0.4, # default 0.4 stdp_w_min = 0.0, # default 0.0 stdp_A_pl = 2,#0.02,# 0.01, # default 0.01 (below 0.01 weights don't change) # => minus in order to get symmetric curve # Data Extraction scale_data = 2.): # Scale features into [0-scale_data] range # BUG fix: # n_feature is somehow a tuple # try: # trial_num = trial_num[0] # except Exception as e: # print("\n\n\n EXCEPTION TRIGGERED !!!! \n\n\n") # pass ############################################################################ ## Function Definitions ############################################################################ def gaussian(x, mu, sig): return np.float16(np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))) def calc_pop_code(feature, rng1, rng2, num): interval=np.float(rng2-rng1)/num means=np.arange(rng1+interval, rng2+interval, interval) pop_code=[gaussian(feature,mu,0.025) for mu in means] return pop_code def PoissonTimes2(t_str=0., t_end=100., rate=10., seed=1.): times = [t_str] rng = np.random.RandomState(seed=seed) cont = True while cont == True: t_next = np.floor(times[-1] + 1000. * next_spike_times(rng,rate)) if t_next < t_end - 30: times.append(t_next[0]) else: cont=False return times[1:] def PoissonTimes(t_str=0., t_end=100., rate=10., seed=1., max_rate=0): if rate>0: interval = (t_end - t_str + 0.) / rate # Add additional reverse_src_del if reverse_src_del == True: times = np.arange(t_str + 30, t_end - 40, interval) # add reverse proportional delay rev_del = np.ceil(max_rate / rate) if rev_del != np.inf: times += rev_del else: times = np.arange(t_str + 30, t_end - 40, interval) return list(times) else: return [] def next_spike_times(rng,rate): return -np.log(1.0-rng.rand(1)) / rate def ismember(a, b): b=[b] bind = {} for i, elt in enumerate(b): if elt not in bind: bind[elt] = i aa=[bind.get(itm, -1) for itm in a] return sum(np.array(aa)+1.) def get_data(trial_num, test_num=10): # trial_num: number of training samples # test_num: number of test samples pass def rand_sample_of_train_set(n): # n: number of features # Return: np.array containing n samples of the training set X = np.load(data_dir) y = np.load(cls_dir) idx = np.random.randint(len(X), size=n) return X[idx], y[idx] ############################################################################ ## Parameters ############################################################################ # Load training data # only load n_rand_data features of training set if rand_data == True: data, cls = rand_sample_of_train_set(trial_num) # load all features of training set else: # load data if its not in passed as fuct argument if data == "load" and cls == "load": data = np.load(data_dir) cls = np.load(cls_dir) # Simulation Parameters trial_num = len(cls) # How many samples (trials) from data will be presented #n_training = 1 # How many times the samples will be iterated n_trials = n_training * trial_num # Total trials time_int_trials = 200. # (ms) Time to present each trial data SIM_TIME = n_trials * time_int_trials # Total simulation time (ms) #ts = 1. # Timestep of Spinnaker (ms) min_del = ts max_del = 144 * ts p.setup(timestep=ts, min_delay=min_del, max_delay=max_del) ## Neuron Numbers #n_feature = 80 # Number of features (= 4 features * 20 neurons) # => 20 neuros: resolution of encoding n_pop = data.shape[1] #4 # Number of neurons in one population (X dim) n_cl = 2 # Number of classes at the output ## Connection Parameters # Weights # wei_src_enc = .2 # From Source Array at input to Encoding Layer(Exc) # wei_enc_filt = .6 # From Encoding Layer to Filtering Layer Exc neurons (Exc) # wei_filt_inh = 0.03 # From Filtering Layer Inh neurons to Exc neurons (Inh) # wei_init_stdp = .0 # From Filtering Layer Exc neurons to Output Layer (Exc) # wei_cls_exc = 0.9 # From Output Layer Exc neurons to Inh neurons (Exc) # wei_cls_inh = 10 # 0.1 # From Output Layer Inh neurons to Exc neurons (Inh) # wei_source_outp = 10. # From Source Array at output to Output Layer Exc neurons (Exc) # wei_noise_poi = 0.02 # Delays if randomness == True: # if True: calculate "del_src_enc" (randomly) new # if False: load previously saved "del_src_enc" if reverse_src_del == True: # calc delays erversly proportional to feature value del_src_enc = np.zeros(n_feature*n_pop) else: del_src_enc = [int(np.random.randint(n_pop)+1) for _ in range(n_feature*n_pop)] np.save("output_files/del_src_enc.npy", del_src_enc) else: #del_src_enc = np.load("output_files/del_src_enc.npy") del_src_enc = np.ones(n_feature*n_pop).astype(int) #[1 for _ in range(n_feature*n_pop)] del_enc_filt = ts del_filt_inh = ts # del_init_stdp = 1. del_cls_exc = ts del_cls_inh = ts # del_source_outp = 1. # del_noise_poi = 1. # Firing Rates noise_poi_rate = 10. max_fr_input = 100. # maximum firing rate at the input layer max_fr_rate_output = 20. # Maximum firing rate at output (supervisory signal) ## Connection Probabilities # prob_filt_inh = .4 # Prob of connectivity inhibitory connections at FilT_Layer # prob_stdp = 1. # Prob of STDP connections # prob_output_inh = .7 # Prob of inhibitory connections at Output Layer # prob_noise_poi_conn = 0.02 ## STDP Parameters # tau_pl = 0.3 # (0.2 - 0.3 works) tau_min = tau_pl # default tau_pl # stdp_w_max = 0.4 # default 0.4 # stdp_w_min = 0.0 # default 0.0 # stdp_A_pl = 0.01 # default 0.01 (below 0.01 weights don't change) stdp_A_min = -stdp_A_pl # default - stdp_A_pl # => minus in order to get symmetric curve ## Neuron Parameters cell_params_lif = {'cm': 0.25,# 0.25, 'i_offset': 0.0, 'tau_m': 20., '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#-50 } ############################################################################ ## Data Extraction ############################################################################ ## Extract Feature Data # scale_data = 2. # Scale features into [0-scale_data] range r,c = np.shape(data) data_rates = np.reshape(data, (1, r*c))[0] # Threshold (to keep spikes in range) thr_data_plus = 30 thr_data_minus = -10 #dd = [d if d<thr_data_plus else thr_data_plus for d in data_rates] #dd = [d if d>thr_data_minus else thr_data_minus for d in dd] # Shift and normalize data #dd2 = np.array(dd) - min(dd) dd2 = np.array(data_rates) - min(data_rates) dd2 = dd2 / max(dd2) * 2 new_data_rates = [] for r in dd2: new_data_rates += calc_pop_code(r, 0., scale_data, n_feature / (n_pop + 0.0)) data_rates = list(max_fr_input*np.array(new_data_rates)) ## Extract Class Data # load class vector #cls = np.load(path_y) cls = np.reshape(cls, (len(cls),1)) # create col vector r_cl, c_cl = np.shape(cls) #cls = list(np.reshape(cls, (1, r_cl * c_cl))[0] - 1) cls = list(np.reshape(cls, (1, r_cl * c_cl))[0]) ## The class and rate information to be used during the simulation outputs = n_training * cls[0:trial_num] # positiv, ints poi_rate = n_training * data_rates[0:trial_num * n_feature] ## Save parameters to be used in test parameter_dict = {"n_feature":n_feature, "n_pop":n_pop,"n_cl":n_cl, "wei_src_enc":wei_src_enc, "wei_enc_filt":wei_enc_filt, "wei_filt_inh":wei_filt_inh, "wei_cls_exc":wei_cls_exc, "wei_cls_inh":wei_cls_inh, "del_enc_filt":del_enc_filt, "del_init_stdp":del_init_stdp, "del_cls_exc":del_cls_exc, "del_cls_inh":del_cls_inh, "trial_num":trial_num, "time_int_trials":time_int_trials, "scale_data":scale_data, "ts":ts,"max_fr_input":max_fr_input, "max_fr_rate_output":max_fr_rate_output, "noise_poi_rate":noise_poi_rate, "max_fr_input":max_fr_input, "max_fr_rate_output":max_fr_rate_output, "prob_filt_inh":prob_filt_inh, "prob_stdp":prob_stdp, "prob_output_inh":prob_output_inh, "prob_noise_poi_conn":prob_noise_poi_conn, "tau_pl":tau_pl, "stdp_w_max":stdp_w_max, "stdp_w_min":stdp_w_min, "stdp_A_pl":stdp_A_pl, "wei_noise_poi":wei_noise_poi, "del_noise_poi":del_noise_poi, "thr_data_plus":thr_data_plus, "thr_data_minus":thr_data_minus } if save == True: np.save("output_files/parameters1",parameter_dict) np.save("output_files/parameters2",del_src_enc) ############################################################################ ## Create populations for different layers ############################################################################ poi_layer = [] enc_layer = [] filt_layer_exc = [] out_layer_exc = [] out_layer_inh = [] out_spike_source = [] # Calculate spike times at the input using the rate information coming from features spike_times = [[] for i in range(n_feature)] for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials ind = i * n_feature for j in range(n_feature): times = PoissonTimes(t_st, t_end, poi_rate[ind+j], np.random.randint(100), max_rate=max(poi_rate)) for t in times: spike_times[j].append(t) if randomness == True: # if True: calculate "spike_times" (randomly) new # uf False: load previously saved "spike_times" np.save('output_files/spike_times_train.npy', spike_times) else: spike_times = np.load('output_files/spike_times_train.npy') # Calculate spike times at the output (as supervisory signal) out_spike_times=[[] for i in range(n_cl)] for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials ind = outputs[i] times = PoissonTimes(t_st, t_end, max_fr_rate_output, np.random.randint(100)) for t in times: out_spike_times[int(ind)].append(t) if randomness == True: # if True: calculate "out_spike_times" (randomly) new # uf False: load previously saved "out_spike_times" np.save('output_files/out_spike_times.npy', out_spike_times) else: out_spike_times = np.load('output_files/out_spike_times.npy') # Spike source of input layer spike_source=p.Population(n_feature, p.SpikeSourceArray, {'spike_times':spike_times}, label='spike_source') # Spike source of output layer (Supervisory signal) for i in range(n_cl): out_spike_source.append(p.Population(1, p.SpikeSourceArray, {'spike_times':[out_spike_times[i]]}, label='out_spike_source')) # Encoding layer and Filtering Layer definitions enc_layer = p.Population(n_feature * n_pop, p.IF_curr_exp, cell_params_lif, label='enc_layer') filt_layer = p.Population(n_feature * n_pop, p.IF_curr_exp, cell_params_lif, label='filt_layer') # Excitatory and Inhibitory population definitions at the output for i in range(n_cl): out_layer_exc.append(p.Population(n_pop, p.IF_curr_exp, cell_params_lif, label='out_layer_exc{}'.format(i))) out_layer_inh.append(p.Population(n_pop, p.IF_curr_exp, cell_params_lif, label='out_layer_inh{}'.format(i))) out_layer_exc[i].record() # Noisy poisson population at the input poisson_input = p.Population(n_pop * 2, p.SpikeSourcePoisson, {"rate":noise_poi_rate}) # Record Spikes enc_layer.record() filt_layer.record() #enc_layer.initialize('v',p.RandomDistribution('uniform',[-51.,-69.])) #filt_layer.initialize('v',p.RandomDistribution('uniform',[-51.,-69.])) ############################################################################ ## Projections ############################################################################ ## Connection List from Spike Source Array to Encoding Layer conn_inp_enc=[] for i in range(n_feature): ind=i*n_pop for j in range(n_pop): conn_inp_enc.append([i,ind+j,wei_src_enc,del_src_enc[ind+j]]) if save == True: np.save("output_files/conn_inp_enc",conn_inp_enc) ## Connection List for Filtering Layer Inhibitory if randomness == True: # if True: calculate conn_filt_inh (randomly) new # uf False: load previously saved conn_filt_inh conn_filt_inh=[] for i in range(n_feature): rng1=i*n_pop rng2=rng1+n_pop inp=range(rng1,rng2) outp=range(0,rng1)+range(rng2,n_feature*n_pop) for ii in inp: for jj in outp: if prob_filt_inh>np.random.rand(): conn_filt_inh.append([ii,jj,wei_filt_inh,del_filt_inh]) if save == True: np.save('output_files/conn_filt_inh.npy', conn_filt_inh) else: conn_filt_inh = np.load('output_files/conn_filt_inh.npy') ## STDP Connection List if randomness == True: # if True: calculate conn_stdp_list (randomly) new # uf False: load previously saved conn_stdp_list conn_stdp_list=[[] for i in range(n_cl)] for i in range(n_cl): # For each population at output layer if use_old_weights == True: cl_weights = np.load( "output_files/stdp_weights{}.npy".format(i)) w = 0 for ii in range(n_pop * n_feature): # For each neuron in filtering layer for jj in range(n_pop): # For each neuron in each population of output layer if prob_stdp > np.random.rand(): # If the prob of connection is satiesfied # Make the connection if use_old_weights == True: conn_stdp_list[i].append([ii, jj, cl_weights[w], del_init_stdp]) w += 1 else: conn_stdp_list[i].append([ii, jj, wei_init_stdp, del_init_stdp]) if use_old_weights == False or save == True: np.save('output_files/conn_stdp_list.npy', conn_stdp_list) else: conn_stdp_list = np.load('output_files/conn_stdp_list.npy') ## Output Layer Inhibitory Connection List if randomness == True: # if True: calculate conn_stdp_list (randomly) new # uf False: load previously saved conn_stdp_list conn_output_inh = [[] for i in range(n_cl) for j in range(n_cl) if i!=j] c = 0 for i in range(n_cl): for j in range(n_cl): if i != j: for ii in range(n_pop): for jj in range(n_pop): if prob_output_inh > np.random.rand(): conn_output_inh[c].append([ii, jj, wei_cls_inh, del_cls_inh]) c += 1 if save == True: np.save("output_files/conn_output_inh.npy",conn_output_inh) else: conn_output_inh = np.load("output_files/conn_output_inh.npy") ## Spike Source to Encoding Layer p.Projection(spike_source, enc_layer, p.FromListConnector(conn_inp_enc)) ## Encoding Layer to Filtering Layer p.Projection(enc_layer, filt_layer, p.OneToOneConnector(weights=wei_enc_filt, delays=del_enc_filt)) ## Filtering Layer Inhibitory p.Projection(filt_layer, filt_layer, p.FromListConnector(conn_filt_inh), target="inhibitory") ## STDP Connection between Filtering Layer and Output Layer timing_rule = p.SpikePairRule(tau_plus=tau_pl, tau_minus=tau_min) weight_rule = p.AdditiveWeightDependence(w_max=stdp_w_max, w_min=stdp_w_min, A_plus=stdp_A_pl, A_minus=stdp_A_min) stdp_model = p.STDPMechanism(timing_dependence=timing_rule, weight_dependence=weight_rule) # STDP connection stdp_proj = [] for j in range(n_cl): stdp_proj.append( p.Projection(filt_layer,out_layer_exc[j], p.FromListConnector(conn_stdp_list[j]), synapse_dynamics = p.SynapseDynamics(slow=stdp_model))) ## Connection between Output Layer neurons c = 0 for i in range(n_cl): p.Projection(out_layer_exc[i], out_layer_inh[i], p.OneToOneConnector(weights=wei_cls_exc, delays=del_cls_exc)) iter_array=[j for j in range(n_cl) if j!=i] for j in iter_array: p.Projection(out_layer_exc[i], out_layer_exc[j], p.FromListConnector(conn_output_inh[c]), target="inhibitory") c += 1 ## Spike Source Array to Output for i in range(n_cl): p.Projection(out_spike_source[i], out_layer_exc[i], p.AllToAllConnector(weights=wei_source_outp, delays=del_source_outp)) iter_array = [j for j in range(n_cl) if j != i] for j in iter_array: p.Projection(out_spike_source[i], out_layer_exc[j], p.AllToAllConnector(weights=wei_source_outp, delays=del_source_outp), target="inhibitory") #for i in range(n_cl): # p.Projection(out_spike_source[i], out_layer_exc[i], p.AllToAllConnector\ # (weights=wei_source_outp, delays=del_source_outp)) # p.Projection(out_spike_source[i], out_layer_exc[1-i], p.AllToAllConnector\ # (weights=wei_source_outp, delays=del_source_outp),target="inhibitory") ## Noisy poisson connection to encoding layer if randomness == True: # if True: connect noise to network # if False: don't use noise in network p.Projection(poisson_input, enc_layer, p.FixedProbabilityConnector(p_connect=prob_noise_poi_conn, weights=wei_noise_poi, delays=del_noise_poi)) ############################################################################ ## Simulation ############################################################################ p.run(SIM_TIME) Enc_Spikes = enc_layer.getSpikes() Filt_Exc_Spikes = filt_layer.getSpikes() Out_Spikes = [[] for i in range(n_cl)] for i in range(n_cl): Out_Spikes[i] = out_layer_exc[i].getSpikes() wei = [] for i in range(n_cl): ww = stdp_proj[i].getWeights() if save == True: np.save("output_files/stdp_weights{}".format(i), ww) wei.append(ww) p.end() ############################################################################ ## Plot ############################################################################ ## Plot 1: Encoding Layer Raster Plot if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Encoding Layer Raster Plot') pylab.hold(True) pylab.plot([i[1] for i in Enc_Spikes], [i[0] for i in Enc_Spikes], ".b") pylab.hold(False) #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 2-1: Filtering Layer Raster Plot if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Filtering Layer Raster Plot') pylab.plot([i[1] for i in Filt_Exc_Spikes], [i[0] for i in Filt_Exc_Spikes], ".b") #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 2-2: Filtering Layer Layer Raster Plot if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron ID') pylab.title('Filtering Layer Layer Raster Plot') pylab.hold(True) pylab.plot([i[1] for i in Filt_Exc_Spikes], [i[0] for i in Filt_Exc_Spikes], ".b") time_ind=[i*time_int_trials for i in range(len(outputs))] for i in range(len(time_ind)): pylab.plot([time_ind[i],time_ind[i]],[0,2000],"r") pylab.hold(False) #pylab.axis([-10,c*SIM_TIME+100,-1,numInp+numOut+numInp+3]) pylab.show() ## Plot 3-1: Output Layer Raster Plot if 0: pylab.figure() pylab.xlabel('Time (ms)') pylab.ylabel('Neuron') pylab.title('Output Layer Raster Plot') pylab.hold(True) c=0 for array in Out_Spikes: pylab.plot([i[1] for i in array], [i[0]+c for i in array], ".b") c+=0.2 pylab.hold(False) pylab.axis([-10,SIM_TIME+100,-1,n_pop+3]) pylab.show() ## Plot 4: STDP WEIGHTS if 1: pylab.figure() pylab.xlabel('Weight ID') pylab.ylabel('Weight Value') pylab.title('STDP weights at the end') #pylab.title('STDP weights at the end' + ' (trail_num=' + str(trial_num) + ')') pylab.hold(True) for i in range(n_cl): pylab.plot(wei[i]) pylab.hold(False) pylab.axis([-10,n_pop*n_feature*n_pop*0.5+10,-stdp_w_max,2*stdp_w_max]) str_legend=["To Cl {}".format(i+1) for i in range(n_cl)] pylab.legend(str_legend) #pylab.show() fname = 'plots/weights_1.png' while True: if os.path.isfile(fname): # if file already exists new_num = int(fname.split('.')[0].split('_')[1]) + 1 fname = fname.split('_')[0] + '_' +str(new_num) + '.png' # if len(fname) == 19: # new_num = int(fname.split('.')[0][-1]) + 1 # fname = fname.split('.')[0][:-1] + str(new_num) + '.png' # elif len(fname) == 20: # new_num = int(fname.split('.')[0][-2:]) + 1 # fname = fname.split('.')[0][:-2] + str(new_num) + '.png' # else: # new_num = int(fname.split('.')[0][-3:]) + 1 # fname = fname.split('.')[0][:-3] + str(new_num) + '.png' else: pylab.savefig(fname) break #pylab.figure() #pylab.xlabel('Weight ID') #pylab.ylabel('Weight Value') #pylab.title('STDP weights at the end') #pylab.hold(True) #pylab.plot(wei[0], "b") #pylab.plot(wei[1], "g") #pylab.hold(False) #pylab.axis([-10, n_pop * n_feature * n_pop * 0.5 + 10, # -stdp_w_max, 2 * stdp_w_max]) #pylab.legend(['To Cl 1','To Cl 2']) #pylab.show() ## Plot 5: Spike Source Spiking Times if 0: pylab.figure() pylab.hold(True) pylab.plot(out_spike_times[0], [1 for i in range(len(out_spike_times[0]))],"x") pylab.plot(out_spike_times[1], [1.05 for i in range(len(out_spike_times[1]))],"x") pylab.hold(False) pylab.title("Spike Source Spiking Times") pylab.axis([-100,SIM_TIME+100,-2,3]) pylab.show() ## Calculate spiking activity of each neuron to each class inputs sum_filt=[[0 for i in range(n_feature*n_pop)] for j in range(n_cl)] sum_filt=np.array(sum_filt) for i in range(n_trials): t_st = i * time_int_trials t_end = t_st + time_int_trials cl = outputs[i] for n,t in Filt_Exc_Spikes: if t >= t_st and t < t_end: sum_filt[int(cl),int(n)] = sum_filt[int(cl), int(n)] + 1 a4=sum_filt[0] b4=sum_filt[1] thr=20 diff_vec=np.abs(a4 - b4) diff_thr=[i if i>thr else 0. for i in diff_vec] diff_ind=[i for i in range(len(diff_thr)) if diff_thr[i]!=0] if save == True: np.save("output_files/diff_ind_filt",diff_ind) diff2 = a4 - b4 diff_thr2=[i if i > thr or i <- thr else 0. for i in diff2] diff_ind2=[i for i in range(len(diff_thr2)) if diff_thr2[i] != 0] if save == True: np.save("output_files/diff_ind_filt2",diff_ind2) np.save("output_files/diff_thr2",diff_thr2) ## Plot 6: Total Spiking Activity of Neurons at Decomposition Layer for Each Class if 0: a4=sum_filt[0] b4=sum_filt[1] pylab.figure() pylab.hold(True) pylab.plot(a4,"b") pylab.plot(b4,"r") pylab.xlabel('Neuron ID') pylab.ylabel('Total Firing Rates Through Trials') pylab.title("Total Spiking Activity of Neurons at Decomposition Layer ", "for Each Class") pylab.hold(False) pylab.legend(["Activity to AN1","Activity to AN2"]) pylab.show()
exc_params, label="inhibitory neurons") stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule(tau_plus=tau, tau_minus=tau, nearest=True), weight_dependence=sim.MultiplicativeWeightDependence(w_min=min_weight, w_max=max_weight, A_plus=a_plus, A_minus=a_minus)) rand_weights = sim.RandomDistribution(boundaries=(min_weight, max_weight)) prob_conn_10pc = sim.FixedProbabilityConnector(conn_prob, allow_self_connections=False, weights=rand_weights) m2s_proj = sim.Projection( master_pop, slave_pop, prob_conn_10pc, target="excitatory", synapse_dynamics=sim.SynapseDynamics(slow=stdp_model)) s2i_proj = sim.Projection( slave_pop, inhibit_pop, prob_conn_10pc, target="excitatory", synapse_dynamics=sim.SynapseDynamics(slow=stdp_model)) i2s_proj = sim.Projection(
ext_stim_inh = sim.Population( n_stim, sim.SpikeSourceArray(spike_times=spike_times_train_dn[i].tolist()), label="Input spike time array inhibitory") # stdp_mechanism = sim.STDPMechanism( # timing_dependence=sim.SpikePairRule(**synaptic_parameters['excitatory_stdp']['timing_dependence']), # weight_dependence=sim.AdditiveWeightDependence(**synaptic_parameters['excitatory_stdp']['weight_dependence']), # weight=synaptic_parameters['excitatory_stdp']['weight'] # ,delay=synaptic_parameters['excitatory_stdp']['delay'], # dendritic_delay_fraction=0 # ) # Determine the connectivity among the population of neuron global_connectivity_reservoir = sim.FixedProbabilityConnector( **connectivity_parameters['global_reservoir']) array_connectivity_small_world_exc_exc = sim.ArrayConnector( connection_matrix_small_world_exc_exc) array_connectivity_small_world_exc_inh = sim.ArrayConnector( connection_matrix_small_world_exc_inh) array_connectivity_small_world_inh_exc = sim.ArrayConnector( connection_matrix_small_world_inh_exc) input_connectivity_exc = sim.FixedNumberPostConnector( **connectivity_parameters['input_exc']) input_connectivity_inh = sim.FixedNumberPostConnector( **connectivity_parameters['input_inh']) input_exc_exc_connections = sim.Projection( ext_stim_exc,
connected_chip_details = { "spinnaker_link_id": 0, } def get_updated_params(params): params.update(connected_chip_details) return params # Setup p.setup(timestep=1.0) # FPGA Retina - Down Polarity retina_pop = p.Population( None, p.external_devices.ExternalFPGARetinaDevice, get_updated_params({ 'retina_key': 0x5, 'mode': p.external_devices.ExternalFPGARetinaDevice.MODE_128, 'polarity': ( p.external_devices.ExternalFPGARetinaDevice.DOWN_POLARITY)}), label='External retina') population = p.Population(256, p.IF_curr_exp(), label='pop_1') p.Projection( retina_pop, population, p.FixedProbabilityConnector(0.1), synapse_type=p.StaticSynapse(weight=0.1)) # q.activate_live_output_for(population) p.run(1000) p.end()
weight_inh = -5.0 * weight_exc pop_exc = p.Population(n_exc, p.IF_curr_exp, {}, label="Excitatory") pop_inh = p.Population(n_inh, p.IF_curr_exp, {}, label="Inhibitory") stim_exc = p.Population(n_exc, p.SpikeSourcePoisson, {"rate": 1000.0}, label="Stim_Exc") stim_inh = p.Population(n_inh, p.SpikeSourcePoisson, {"rate": 1000.0}, label="Stim_Inh") delays_exc = RandomDistribution("normal", [1.5, 0.75], boundaries=(1.0, 14.4)) weights_exc = RandomDistribution("normal", [weight_exc, 0.1], boundaries=(0, numpy.inf)) conn_exc = p.FixedProbabilityConnector(0.1, weights=weights_exc, delays=delays_exc) delays_inh = RandomDistribution("normal", [0.75, 0.375], boundaries=(1.0, 14.4)) weights_inh = RandomDistribution("normal", [weight_inh, 0.1], boundaries=(-numpy.inf, 0)) conn_inh = p.FixedProbabilityConnector(0.1, weights=weights_inh, delays=delays_inh) p.Projection(pop_exc, pop_exc, conn_exc, target="excitatory") p.Projection(pop_exc, pop_inh, conn_exc, target="excitatory") p.Projection(pop_inh, pop_inh, conn_inh, target="inhibitory") p.Projection(pop_inh, pop_exc, conn_inh, target="inhibitory") conn_stim = p.OneToOneConnector(weights=weight_exc, delays=1.0) p.Projection(stim_exc, pop_exc, conn_stim, target="excitatory")
def get_updated_params(params): params.update(connected_chip_details) return params # Setup p.setup(timestep=1.0) # FPGA Retina - Down Polarity retina_pop = p.Population( None, p.external_devices.ExternalFPGARetinaDevice, get_updated_params({ 'retina_key': 0x5, 'mode': p.external_devices.ExternalFPGARetinaDevice.MODE_128, 'polarity': (p.external_devices.ExternalFPGARetinaDevice.DOWN_POLARITY) }), label='External retina') population = p.Population(256, p.IF_curr_exp(), label='pop_1') p.Projection(retina_pop, population, p.FixedProbabilityConnector(0.1), synapse_type=p.StaticSynapse(weight=0.1)) # q.activate_live_output_for(population) p.run(1000) p.end()
#distWeightL1E2E = RandomDistribution('exponential', [L1MeanWeightX2X], rng=rng, boundaries=[0.0, 7.0], constrain='redraw') #distWeightL1I2E = RandomDistribution('exponential', [L1MeanWeightI2X], rng=rng, boundaries=[0.0, 7.0], constrain='redraw') populations = list() projections = list() ## Populations # Layer 1 (input layer) populations: populations.append(p.Population(nL1ExcitNeurons, p.SpikeSourcePoisson, {'rate' : noiseRate, 'duration' : runTime}, label='L1Excit')) populations.append(p.Population(nL1InhibNeurons, p.IF_curr_exp, cell_params_lif, label='L1Inhib')) # Layer 2 (hidden layer) populations: populations.append(p.Population(nL2ExcitNeurons, p.IF_curr_exp, cell_params_lif, label='L2Excit')) ## Projections # Starting in layer 1: projections.append(p.Projection(populations[L1E], populations[L1I], p.FixedProbabilityConnector(p_connect=pL1E2I, weights=L1MeanWeightX2X, delays=E2ImeanDelay), target='excitatory')) # From excit to its own inhib neurons projections.append(p.Projection(populations[L1E], populations[L2E], p.FixedProbabilityConnector(p_connect=pL1E2E, weights=L1MeanWeightX2X, delays=E2ImeanDelay), target='excitatory')) # Feedforward excitation #projections.append(p.Projection(populations[L1I], populations[L2E], p.FixedProbabilityConnector(p_connect=pL1I2E, weights=distWeightL1I2E, delays=I2EmeanDelay), target='inhibitory')) # Feedforward inhibition #populations[L1E].record() #populations[L1I].record() #populations[L2E].record() populations[L1I].record_v() populations[L2E].record_v() p.run(runTime) v1I = populations[L1I].get_v(compatible_output=True) v2E = populations[L2E].get_v(compatible_output=True) gsyn = None spikes = 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
sim.Projection( IAddPre[i], pre_pop, ee_connector, receptor_type='excitatory', synapse_type=sim.StaticSynapse(weight=JEE * 0.05)) for i in range(len(IAddPost)): sim.Projection( IAddPost[i], post_pop, ee_connector, receptor_type='excitatory', synapse_type=sim.StaticSynapse(weight=JEE * 0.05)) # Plastic Connections between pre_pop and post_pop stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule( tau_plus=20., tau_minus=20.0, A_plus=0.02, A_minus=0.02), weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=0.01)) plastic_projection = sim.Projection( pre_pop, post_pop, sim.FixedProbabilityConnector(p_connect=0.5), synapse_type=stdp_model) # +-------------------------------------------------------------------+ # | Simulation and results | # +-------------------------------------------------------------------+ # Run simulation sim.run(simtime) print("Weights:{}".format(plastic_projection.get('weight', 'list'))) print("plastic1:{}".format(plastic_projection.get('tau_plus', 'list'))) print("plastic2andweights:{}".format(plastic_projection.get( ['weight', 'tau_plus'], 'list'))) # End simulation on SpiNNaker
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
ee_connector, receptor_type='excitatory', synapse_type=sim.StaticSynapse(weight=JEE * 0.05)) # Plastic Connections between pre_pop and post_pop stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule(tau_plus=20., tau_minus=20.0, A_plus=0.02, A_minus=0.02), weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=0.9)) plastic_projection = sim.Projection( pre_pop, post_pop, sim.FixedProbabilityConnector(p_connect=0.5), synapse_type=stdp_model) # +-------------------------------------------------------------------+ # | Simulation and results | # +-------------------------------------------------------------------+ # Record neurons' potentials pre_pop.record(['v', 'spikes']) post_pop.record(['v', 'spikes']) # Run simulation sim.run(simtime) print("Weights:{}".format(plastic_projection.get('weight', 'list')))
cell_params_lif, label='L1Inhib')) # Layer 2 (hidden layer) populations: populations.append( p.Population(nL2ExcitNeurons, p.IF_curr_exp, cell_params_lif, label='L2Excit')) ## Projections # Starting in layer 1: projections.append( p.Projection(populations[L1E], populations[L1I], p.FixedProbabilityConnector(p_connect=pL1E2I, weights=L1MeanWeightX2X, delays=E2ImeanDelay), target='excitatory')) # From excit to its own inhib neurons projections.append( p.Projection(populations[L1E], populations[L2E], p.FixedProbabilityConnector(p_connect=pL1E2E, weights=L1MeanWeightX2X, delays=E2ImeanDelay), target='excitatory')) # Feedforward excitation #projections.append(p.Projection(populations[L1I], populations[L2E], p.FixedProbabilityConnector(p_connect=pL1I2E, weights=distWeightL1I2E, delays=I2EmeanDelay), target='inhibitory')) # Feedforward inhibition #populations[L1E].record() #populations[L1I].record() #populations[L2E].record() populations[L1I].record_v()