def setupLayerRN(params, neuronModel, cell_params, injectionPopulations, popPoissionNoiseSource, populationsRN): #create a single RN population divided into virtual clusters one per VR #this will be fed by the noise population and modulated by the relevant ratecoded neuron #to create a rate coded population numVR = params['NUM_VR'] rnClusterSize = int(params['CLUSTER_SIZE']) #* params['NETWORK_SCALE'] rnPopSize = rnClusterSize * numVR popName = 'popRN' popRN = spynnaker.Population(rnPopSize, neuronModel, cell_params, label=popName) populationsRN.append(popRN) #connect one random poisson neuron to each RN neuron weight = params['WEIGHT_POISSON_TO_CLUSTER_RN'] delay = params['DELAY_POISSON_TO_CLUSTER_RN'] connections = utils.fromList_OneRandomSrcForEachTarget(popPoissionNoiseSource._size,popRN._size,weight,delay) projPoissonToClusterRN = spynnaker.Projection(popPoissionNoiseSource, popRN, spynnaker.FromListConnector(connections), target='excitatory') vr = 0 for injectionPopn in injectionPopulations: connections = list() for fromNeuronIdx in range(injectionPopn._size): #connect the correct VR ratecode neuron in popRateCodeSpikes to corresponding subsection (cluster) of the RN population weight = params['WEIGHT_RATECODE_TO_CLUSTER_RN'] firstIndex = vr * rnClusterSize lastIndex = firstIndex + rnClusterSize - 1 connections += utils.fromList_SpecificNeuronToRange(fromNeuronIdx,firstIndex,lastIndex,weight,params['MIN_DELAY_RATECODE_TO_CLUSTER_RN'],params['MAX_DELAY_RATECODE_TO_CLUSTER_RN']) vr = vr + 1 #after the last neuron in the current injection pop, create a projection to the RN projRateToClusterRN = spynnaker.Projection(injectionPopn, popRN, spynnaker.FromListConnector(connections), target='excitatory') print 'Added projection to RN of ', len(connections), " connections from injection pop ", injectionPopn.label, "(size ", injectionPopn._size,")"
def createIntraPopulationWTA(popn, numClusters, weight, delay, connectivity, createSingleProjection): allConnections = [] clusterSize = popn._size / numClusters for i in range(numClusters): for j in range(numClusters): if i != j: srcFirstIdx = i * clusterSize srcLastIdx = srcFirstIdx + clusterSize - 1 targFirstIdx = j * clusterSize targLastIdx = targFirstIdx + clusterSize - 1 connections = fromList_fromRangeToRange( srcFirstIdx, srcLastIdx, targFirstIdx, targLastIdx, weight, delay, delay, connectivity) if (createSingleProjection): allConnections += connections else: projInhibitory = spynnaker.Projection( popn, popn, spynnaker.FromListConnector(connections), target='inhibitory') #print ' WTA connections', projInhibitory.getWeights() if (createSingleProjection): projInhibitory = spynnaker.Projection( popn, popn, spynnaker.FromListConnector(allConnections), target='inhibitory')
def nealprojection(self, pre_neurons, post_neurons, connector_list, inh_exc): #projection method for SpiNNaker conn_list = spinn.FromListConnector(connector_list) spinn.Projection(pre_neurons, post_neurons, conn_list, receptor_type=inh_exc)
def test(spikeTimes, trained_weights,label): #spikeTimes = extractSpikes(sample) runTime = int(max(max(spikeTimes)))+100 ########################################## sim.setup(timestep=1) pre_pop = sim.Population(input_size, sim.SpikeSourceArray, {'spike_times': spikeTimes}, label="pre_pop") post_pop = sim.Population(output_size, sim.IF_curr_exp , cell_params_lif, label="post_pop") if len(trained_weights) > input_size: weigths = [[0 for j in range(output_size)] for i in range(input_size)] #np array? size 1024x25 k=0 for i in range(input_size): for j in range(output_size): weigths[i][j] = trained_weights[k] k += 1 else: weigths = trained_weights connections = [] #k = 0 for n_pre in range(input_size): # len(untrained_weights) = input_size for n_post in range(output_size): # len(untrained_weight[0]) = output_size; 0 or any n_pre #connections.append((n_pre, n_post, weigths[n_pre][n_post]*(wMax), __delay__)) connections.append((n_pre, n_post, weigths[n_pre][n_post]*(wMax)/max(trained_weights), __delay__)) # #k += 1 prepost_proj = sim.Projection(pre_pop, post_pop, sim.FromListConnector(connections), synapse_type=sim.StaticSynapse(), receptor_type='excitatory') # no more learning !! #inhib_proj = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory') # no more lateral inhib post_pop.record(['v', 'spikes']) sim.run(runTime) neo = post_pop.get_data(['v', 'spikes']) spikes = neo.segments[0].spiketrains v = neo.segments[0].filter(name='v')[0] f1=pplt.Figure( # plot voltage pplt.Panel(v, ylabel="Membrane potential (mV)", xticks=True, yticks=True, xlim=(0, runTime+100)), # raster plot pplt.Panel(spikes, xlabel="Time (ms)", xticks=True, yticks=True, markersize=2, xlim=(0, runTime+100)), title='Test with label ' + str(label), annotations='Test with label ' + str(label) ) f1.save('plot/'+str(trylabel)+str(label)+'_test.png') f1.fig.texts=[] print("Weights:{}".format(prepost_proj.get('weight', 'list'))) weight_list = [prepost_proj.get('weight', 'list'), prepost_proj.get('weight', format='list', with_address=False)] #predict_label= sim.end() return spikes
def setupLayerAN(params, settings, neuronModel, cell_params, popClassActivation, popPoissionNoiseSource, populationsPN, populationsAN,learning,projectionsPNAN): #create an Association Neuron AN cluster population per class #this will be fed by: #1) PN clusters via plastic synapses #2) Class activation to innervate the correct AN cluster for a given input #3) laterally inhibit between AN clusters numClasses = params['NUM_CLASSES'] anClusterSize = int(params['CLUSTER_SIZE']) #* params['NETWORK_SCALE'] for an in range(numClasses): popName = 'popClusterAN_' + str(an) ; popClusterAN = spynnaker.Population(anClusterSize, neuronModel, cell_params, label=popName) populationsAN.append(popClusterAN) #connect neurons in every PN popn to x% (e.g 50%) neurons in this AN cluster for pn in range(len(populationsPN)): if learning: projLabel = 'Proj_PN' + str(pn) + '_AN' + str(an) projClusterPNToClusterAN = connectClusterPNtoAN(params,populationsPN[pn],popClusterAN,float(settings['OBSERVATION_EXPOSURE_TIME_MS']),projLabel) projectionsPNAN.append(projClusterPNToClusterAN) #keep handle to use later for saving off weights at end of learning else: #Without plasticity, create PNAN FromList connectors using weights saved during learning stage connections = utils.loadListFromFile(getWeightsFilename(settings,'PNAN',pn,an)) #print 'Loaded weightsList[',pn,',',an,']',connections tupleList = utils.createListOfTuples(connections) #new version only accepts list of tuples not list of lists #print 'tupleList[',pn,',',an,']',tupleList conn = spynnaker.FromListConnector(tupleList) projClusterPNToClusterAN = spynnaker.Projection(populationsPN[pn], popClusterAN,conn, target='excitatory') if learning: #use the class activity input neurons to create correlated activity during learining in the corresponding class cluster weight = params['WEIGHT_CLASS_EXCITATION_TO_CLUSTER_AN'] connections = utils.fromList_SpecificNeuronToAll(an,anClusterSize,weight,params['MIN_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN'],params['MAX_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN']) projClassActivityToClusterAN = spynnaker.Projection(popClassActivation, popClusterAN, spynnaker.FromListConnector(connections), target='excitatory') else: #testing #send spikes on these outputs back to correct host port , these will be used to determine winner etc anHostReceivePort = int(settings['AN_HOST_RECEIVE_PORT']) ExternalDevices.activate_live_output_for(popClusterAN,port=anHostReceivePort) #connect each AN cluster to inhibit every other AN cluster utils.createInterPopulationWTA(populationsAN,params['WEIGHT_WTA_AN_AN'],params['DELAY_WTA_AN_AN'],float(params['CONNECTIVITY_WTA_AN_AN'])) #inhibit other non-corresponding class clusters if learning: weight = params['WEIGHT_CLASS_INHIBITION_TO_CLUSTER_AN'] for activeCls in range(numClasses): connections = utils.fromList_SpecificNeuronToAll(activeCls,anClusterSize,weight,params['MIN_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN'],params['MAX_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN']) for an in range(numClasses): if an != activeCls: projClassActivityToClusterAN = spynnaker.Projection(popClassActivation, populationsAN[an], spynnaker.FromListConnector(connections), target='inhibitory')
def obtain_synapses(wiring_plan): rng = NumpyRNG(seed=64754) delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng) weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng) flat_iter = [ (i,j,k,xaxis) for i,j in enumerate(filtered) for k,xaxis in enumerate(j) ] index_exc = list(set( source for (source,j,target,xaxis) in flat_iter if xaxis==1 or xaxis == 2 )) index_inh = list(set( source for (source,j,target,xaxis) in flat_iter if xaxis==-1 or xaxis == -2 )) EElist = [] IIlist = [] EIlist = [] IElist = [] for (source,j,target,xaxis) in flat_iter: delay = delay_distr.next() weight = 1.0 # will be updated later. if xaxis==1 or xaxis == 2: if target in index_inh: EIlist.append((source,target,delay,weight)) else: EElist.append((source,target,delay,weight)) if xaxis==-1 or xaxis == -2: if target in index_exc: IElist.append((source,target,delay,weight)) else: IIlist.append((source,target,delay,weight)) conn_ee = sim.FromListConnector(EElist) conn_ie = sim.FromListConnector(IElist) conn_ei = sim.FromListConnector(EIlist) conn_ii = sim.FromListConnector(IIlist) return (conn_ee, conn_ie, conn_ei, conn_ii,index_exc,index_inh)
def setupProjection_PN_KC(pn_population,kc_population): connectionList = list() # Connection list between PN and KC for each_kc_cell in xrange(NUM_KC_CELLS): count = 6 selectedCells = random.sample(xrange(NUM_PN_CELLS),count) for each_pn_cell in selectedCells: single_coonection = (each_pn_cell,each_kc_cell) connectionList.append(single_coonection) pnkcProjection = spynnaker.Projection(pn_population, kc_population, spynnaker.FromListConnector(connectionList), spynnaker.StaticSynapse(weight=WEIGHT_PN_KC, delay=DELAY_PN_KC)) return pnkcProjection
def setupProjection_PN_KC(pn_population, kc_population): WEIGHT_PN_KC = 5 DELAY_PN_KC = 1.0 NUM_KC_CELLS = 2000 NUM_PN_CELLS = 784 connectionList = list() # Build up a connection list between PN and KC for each_kc_cell in xrange(NUM_KC_CELLS): count = random.randint( 5, 7) # How many pn_cells will connect to this kc_cell selectedCells = random.sample( xrange(NUM_PN_CELLS), count) # Index of randomly selected PN cells for each_pn_cell in selectedCells: single_coonection = (each_pn_cell, each_kc_cell) connectionList.append(single_coonection) pnkcProjection = spynnaker.Projection( pn_population, kc_population, spynnaker.FromListConnector(connectionList), spynnaker.StaticSynapse(weight=WEIGHT_PN_KC, delay=DELAY_PN_KC)) return pnkcProjection
#create connections filenames=[ "0Conv2D_14x14x16", "1Conv2D_12x12x32", "2Conv2D_12x12x8", "4Dense_5" ] for i in range(len(network)-1): ex = np.genfromtxt(filenames[i]+"_excitatory") inh = np.genfromtxt(filenames[i]+"_inhibitory") ex[:,2] /= weight_scale inh[:,2] /= weight_scale pynn.Projection(network[i], network[i+1], pynn.FromListConnector(ex, ['weight', 'delay']), receptor_type='excitatory') pynn.Projection(network[i], network[i+1], pynn.FromListConnector(inh, ['weight', 'delay']), receptor_type='inhibitory') #network[i+1].initialize(v=0.0, isyn_exc=0.0, isyn_inh=0.0) #'isyn_exc': 0.0, 'isyn_inh': 0.0, #set input firstrun = True for trial, j in enumerate(test_data): if firstrun: firstrun = False else: pynn.reset() try: for i in range(len(network)-1):
num_test = len(test_data) # create network network, labels, n_neurons = load_assembly( path, "tsfold" + str(fold) + "_nest", pynn) # load connections for l in range(len(network) - 1): conn = np.genfromtxt(path + "/" + labels[l + 1]) # when we switch to spinnaker we need to split the connection in ex and inh: ex = conn[conn[:, 2] > 0] inh = conn[conn[:, 2] < 0] if ex.any(): ex[:, 2] *= weight_scale pynn.Projection(network[l], network[l+1], \ pynn.FromListConnector(ex, ['weight', 'delay']), receptor_type='excitatory') if inh.any(): inh[:, 2] *= weight_scale pynn.Projection(network[l], network[l+1], \ pynn.FromListConnector(inh, ['weight', 'delay']), receptor_type='inhibitory') network[l + 1].set(**cell_params) network[l + 1].initialize(v=network[l + 1].get('v_rest')) # record spikes if plot: for layer in network: layer.record("spikes") else: network[-1].record("spikes")
#create connections filenames = [ "0Conv2D_30x30x16", "1Conv2D_28x28x32", "2Conv2D_28x28x8", "4Dense_5" ] weight_scale = 1 for i in range(len(network) - 1): ex = np.genfromtxt(filenames[i] + "_excitatory") inh = np.genfromtxt(filenames[i] + "_inhibitory") ex[:, 2] /= weight_scale inh[:, 2] /= weight_scale pynn.Projection(network[i], network[i + 1], pynn.FromListConnector(ex, ['weight', 'delay']), receptor_type='excitatory') pynn.Projection(network[i], network[i + 1], pynn.FromListConnector(inh, ['weight', 'delay']), receptor_type='inhibitory') network[i + 1].initialize(v=0.0) #set input x_flat = np.ravel(data) rescale_fac = 1000 / (1000 * dt) #rescale_fac = 1000 / (self.config.getint('input', 'input_rate') *self._dt) rates = 1000 * x_flat / rescale_fac #print(rates) network[0].set(rate=rates)
conn_prob = 0.1, weight=input_strength, new_format=new_conn_list) exc2exc = dist_dep_conn_3d_3d(exc_3d, exc_3d, dist_rule = "exp(-sqrt(d*d))", conn_prob = 0.2, weight=input_strength, new_format=new_conn_list) exc2inh = dist_dep_conn_3d_3d(exc_3d, inh_3d, dist_rule = "exp(-sqrt(d*d))", conn_prob = 0.2, weight=input_strength, new_format=new_conn_list) connectors = {} connectors['in2exc'] = sim.FromListConnector(in2exc) connectors['in2inh'] = sim.FromListConnector(in2inh) #connectors['in2inv'] = sim.FromListConnector(in2inv) connectors['inh2exc'] = sim.FromListConnector(inh2exc) connectors['inh2inh'] = sim.FromListConnector(inh2inh) connectors['exc2inh'] = sim.FromListConnector(exc2inh) connectors['exc2exc'] = sim.FromListConnector(exc2exc) connectors['exc2id'] = sim.AllToAllConnector(allow_self_connections=False, weights=normal_distribution, delays=exc_delay_dist) #~ #~ connectors['exc2id'] = sim.FixedProbabilityConnector(0.2, allow_self_connections=False, #~ weights=normal_distribution, #~ delays=exc_delay_dist #~ )
import pyNN.spiNNaker as sim sim.setup() p1 = sim.Population(3, sim.SpikeSourceArray, {"spike_times": [1.0, 2.0, 3.0]}) p2 = sim.Population(3, sim.SpikeSourceArray, {"spike_times": [[10.0], [20.0], [30.0]]}) p3 = sim.Population(4, sim.IF_cond_exp, {}) sim.Projection(p2, p3, sim.FromListConnector([ (0, 0, 0.1, 1.0), (1, 1, 0.1, 1.0), (2, 2, 0.1, 1.0)])) #sim.Projection(p1, p3, sim.FromListConnector([(0, 3, 0.1, 1.0)])) # works if this line is added sim.run(100.0)
stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule(tau_plus=tau_plus, tau_minus=tau_minus, nearest=True), weight_dependence=sim.AdditiveWeightDependence(w_min=min_weight, w_max=max_weight, A_plus=a_plus, A_minus=a_minus)) rng = sim.NumpyRNG(seed=int(time.time())) #rng = sim.NumpyRNG(seed=1) e2e_lst, e2i_lst, i2e_lst, i2i_lst = connections(max_conn_per_neuron, num_exc, num_inh, max_delay) e2e_conn = sim.FromListConnector(e2e_lst) e2i_conn = sim.FromListConnector(e2i_lst) i2e_conn = sim.FromListConnector(i2e_lst) i2i_conn = sim.FromListConnector(i2i_lst) o2o_conn = sim.OneToOneConnector(weights=weight_to_spike, delays=1.) #~ print("-----------------------------------------------------------------") #~ print("-----------------------------------------------------------------") #~ print("Excitatory to Excitatory connections") #~ print("-----------------------------------------------------------------") e2e_proj = sim.Projection( exc_pop, exc_pop, e2e_conn, target="excitatory",
def run_test(w_list, cell_para, spike_source_data): #Du.set_trace() pop_list = [] p.setup(timestep=1.0, min_delay=1.0, max_delay=3.0) #input poisson layer input_size = w_list[0].shape[0] #print w_list[0].shape[0] #print w_list[1].shape[0] list = [] for j in range(input_size): list.append(spike_source_data[j]) pop_in = p.Population(input_size, p.SpikeSourceArray, {'spike_times': list}) pop_list.append(pop_in) #for j in range(input_size): #pop_in[j].spike_times = spike_source_data[j] #pop_in = p.Population(input_size, p.SpikeSourceArray, {'spike_times' : []}) #for j in range(input_size): #pop_in[j].spike_times = spike_source_data[j] #pop_list.append(pop_in) #count =0 #print w_list[0].shape[0] for w in w_list: input_size = w.shape[0] #count = count+1 #print count output_size = w.shape[1] #pos_w = np.copy(w) #pos_w[pos_w < 0] = 0 #neg_w = np.copy(w) #neg_w[neg_w > 0] = 0 conn_list_exci = [] conn_list_inhi = [] #k_size=in_size-out_size+1 for x_ind in range(input_size): for y_ind in range(output_size): weights = w[x_ind][y_ind] #for i in range(w.shape[1]): if weights > 0: conn_list_exci.append((x_ind, y_ind, weights, 1.)) elif weights < 0: conn_list_inhi.append((x_ind, y_ind, weights, 1.)) #print output_size pop_out = p.Population(output_size, p.IF_curr_exp, cell_para) if len(conn_list_exci) > 0: p.Projection(pop_in, pop_out, p.FromListConnector(conn_list_exci), target='excitatory') if len(conn_list_inhi) > 0: p.Projection(pop_in, pop_out, p.FromListConnector(conn_list_inhi), target='inhibitory') #p.Projection(pop_in, pop_out, p.AllToAllConnector(weights = pos_w), target='excitatory') #p.Projection(pop_in, pop_out, p.AllToAllConnector(weights = neg_w), target='inhibitory') pop_list.append(pop_out) pop_in = pop_out pop_out.record() run_time = np.ceil(np.max(spike_source_data)[0] / 1000.) * 1000 #print run_time p.run(run_time) spikes = pop_out.getSpikes(compatible_output=True) return spikes
injectionConnection = [(0, 0, weight_to_spike, 1)] all_to_one_connection = list() for i in range(0, nNeurons): singleConnection = (i, 0, weight_to_spike, delay) all_to_one_connection.append(singleConnection) spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) populations.append( p.Population(nNeurons, p.IF_cond_exp, cell_params_lif, label='pop_2')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(loopConnections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) projections.append( p.Projection(populations[0], populations[2], p.FromListConnector(all_to_one_connection))) populations[0].record_v() populations[0].record_gsyn() populations[0].record() p.run(5000) p.end()
def setupLayerPN(params, neuronModel, cell_params, populationsRN, populationsPN): #create a projection neuron PN cluster population per VR #this will be fed by the equivalent RN population and will laterally #inhibit between clusters numVR = int(params['NUM_VR']) #print 'PN layer, no. VR: ' , numVR pnClusterSize = int(params['CLUSTER_SIZE'] * params['NETWORK_SCALE']) maxNeuronsPerCore = int(params['MAX_NEURONS_PER_CORE']) maxVrPerPop = maxNeuronsPerCore / pnClusterSize #how many cores were needed to accomodate RN layer (1 pynn pop in this case) numCoresRN = utils.coresRequired(populationsRN, maxNeuronsPerCore) #print 'The RN layer is taking up ', numCoresRN, ' cores' coresAvailablePN = int(params['CORES_ON_BOARD'] - params['NUM_CLASSES'] - numCoresRN - 3) # 2 x input, 1 x noise source #print 'PN layer, no. cores available:' , coresAvailablePN vrPerPop = int(ceil(float(numVR) / float(coresAvailablePN))) if vrPerPop > maxVrPerPop: print 'The number of VR and/or cluster size stipulated for \ this model are too a large for the capacity of this board.' quit #print 'PN layer, no. VRs per population will be: ', vrPerPop pnPopSize = pnClusterSize * vrPerPop #print 'PN layer, neurons per population will be: ', pnPopSize numPopPN = int(ceil(float(numVR) / float(vrPerPop))) #print 'PN layer, number of populations(cores) used will be: ', numPopPN #print 'PN layer, spare (unused) cores : ', coresAvailablePN - numPopPN weightPNPN = float(params['WEIGHT_WTA_PN_PN']) delayPNPN = int(params['DELAY_WTA_PN_PN']) connectivityPNPN = float(params['CONNECTIVITY_WTA_PN_PN']) for p in range(numPopPN): popName = 'popPN_' + str(p) popPN = spynnaker.Population(pnPopSize, neuronModel, cell_params, label=popName) #print 'created population ', popName populationsPN.append(popPN) #create a FromList to feed each PN neuron in this popn from its #corresponding RN neuron in the single monolithic RN popn weightRNPN = float(params['WEIGHT_RN_PN']) delayRNPN = int(params['DELAY_RN_PN']) rnStartIdx = p * pnPopSize rnEndIdx = rnStartIdx + pnPopSize - 1 # The last PN popn will often have unneeded 'ghost' clusters at #the end due to imperfect dstribution of VRs among cores # As there is no RN cluster that feeds these (RN is one pop of the #correct total size) so the connections must stop at the end of RN rnMaxIdx = populationsRN[0]._size - 1 if rnEndIdx > rnMaxIdx: rnEndIdx = rnMaxIdx #clamp to the end of the RN population pnEndIdx = rnEndIdx - rnStartIdx connections = utils.fromList_OneToOne_fromRangeToRange( rnStartIdx, rnEndIdx, 0, pnEndIdx, weightRNPN, delayRNPN, delayRNPN) projClusterRNToClusterPN = spynnaker.Projection( populationsRN[0], popPN, spynnaker.FromListConnector(connections), target='excitatory') #within this popn only, connect each PN sub-population VR #"cluster" to inhibit every other if vrPerPop > 1: utils.createIntraPopulationWTA(popPN, vrPerPop, weightPNPN, delayPNPN, connectivityPNPN, True) #Also connect each PN cluster to inhibit every other cluster utils.createInterPopulationWTA(populationsPN, weightPNPN, delayPNPN, connectivityPNPN)
label=RECEIVER_LABEL2) sim.external_devices.activate_live_output_for(synfire1) sim.external_devices.activate_live_output_for(synfire2) loop_conns = list() for i in range(0, n_neurons - 1): single_connection = (i, i + 1, weight_to_spike, delay) loop_conns.append(single_connection) print(loop_conns) input_proj = sim.Projection(input, synfire1, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=1)) synfire1_proj = sim.Projection(synfire1, synfire1, sim.FromListConnector(loop_conns)) synfire2_proj = sim.Projection(synfire2, synfire2, sim.FromListConnector(loop_conns)) """ s_neo = synfire1.get_data(variables=["spikes"]) spikes = s_neo.segments[0].spiketrains print spikes s_neo = synfire2.get_data(variables=["spikes"]) spikes = s_neo.segments[0].spiketrains print spikes """ sim.run(simtime) sim.end()
}) subsampled = p.Population( subsample_size * subsample_size, # size p.IF_curr_exp, # Neuron Type cell_params, # Neuron Parameters label="Input") # Label # select one population to observe with the visualiser in tools/visualiser # the visualiser needs to be started with the following configuration files: # ./visualiser -c retina_full_128.ini for observing the retina input # ./visualiser -c retina_32_128pc.ini for observing the subsampling population input_pol_0.record() # to visualise the retina input #subsampled.record() # to visualise the subsampled input p1 = p.Projection(input_pol_0, subsampled, p.FromListConnector( subSamplerConnector2D(128, subsample_size, .25, 1)), label='subsampling projection') p2 = p.Projection(input_pol_1, subsampled, p.FromListConnector( subSamplerConnector2D(128, subsample_size, .25, 1)), label='subsampling projection') p.run(runtime) # Simulation time p.end()
def sim_runner(wg): #import pyNN.neuron as sim try: import pyNN.spiNNaker as sim except: import pyNN.neuron as sim nproc = sim.num_processes() node = sim.rank() print(nproc) #import mpi4py #threads = sim.rank() threads = 1 rngseed = 98765 parallel_safe = False #extra = {'threads' : threads} # Get some hippocampus connectivity data, based on a conversation with # academic researchers on GH: # https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed # scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware. # conditionally get files if they don't exist. # This is literally the starting point of the connection map path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx' if not os.path.exists(path_xl): os.system( 'wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx' ) xl = pd.ExcelFile(path_xl) dfall = xl.parse() dfall.loc[0].keys() dfm = dfall.as_matrix() rcls = dfm[:, :1] # real cell labels. rcls = rcls[1:] rcls = {k: v for k, v in enumerate(rcls) } # real cell labels, cast to dictionary import pickle with open('cell_names.p', 'wb') as f: pickle.dump(rcls, f) pd.DataFrame(rcls).to_csv('cell_names.csv', index=False) filtered = dfm[:, 3:] filtered = filtered[1:] rng = NumpyRNG(seed=64754) delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng) weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng) sanity_e = [] sanity_i = [] EElist = [] IIlist = [] EIlist = [] IElist = [] with open('wire_map_online.p', 'wb') as f: pickle.dump(filtered, f) for i, j in enumerate(filtered): for k, xaxis in enumerate(j): if xaxis == 1 or xaxis == 2: source = i sanity_e.append(i) target = k if xaxis == -1 or xaxis == -2: sanity_i.append(i) source = i target = k index_exc = list(set(sanity_e)) index_inh = list(set(sanity_i)) import pickle with open('cell_indexs.p', 'wb') as f: returned_list = [index_exc, index_inh] pickle.dump(returned_list, f) ''' import numpy a = numpy.asarray(index_exc) numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",") a = numpy.asarray(index_inh) numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",") ''' for i, j in enumerate(filtered): for k, xaxis in enumerate(j): if xaxis == 1 or xaxis == 2: source = i sanity_e.append(i) target = k delay = delay_distr.next() weight = 1.0 if target in index_inh: EIlist.append((source, target, delay, weight)) else: EElist.append((source, target, delay, weight)) if xaxis == -1 or xaxis == -2: sanity_i.append(i) source = i target = k delay = delay_distr.next() weight = 1.0 if target in index_exc: IElist.append((source, target, delay, weight)) else: IIlist.append((source, target, delay, weight)) internal_conn_ee = sim.FromListConnector(EElist) ee = internal_conn_ee.conn_list ee_srcs = ee[:, 0] ee_tgs = ee[:, 1] internal_conn_ie = sim.FromListConnector(IElist) ie = internal_conn_ie.conn_list ie_srcs = set([int(e[0]) for e in ie]) ie_tgs = set([int(e[1]) for e in ie]) internal_conn_ei = sim.FromListConnector(EIlist) ei = internal_conn_ei.conn_list ei_srcs = set([int(e[0]) for e in ei]) ei_tgs = set([int(e[1]) for e in ei]) internal_conn_ii = sim.FromListConnector(IIlist) ii = internal_conn_ii.conn_list ii_srcs = set([int(e[0]) for e in ii]) ii_tgs = set([int(e[1]) for e in ii]) for e in internal_conn_ee.conn_list: assert e[0] in ee_srcs assert e[1] in ee_tgs for i in internal_conn_ii.conn_list: assert i[0] in ii_srcs assert i[1] in ii_tgs ml = len(filtered[1]) + 1 pre_exc = [] post_exc = [] pre_inh = [] post_inh = [] rng = NumpyRNG(seed=64754) delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng) plot_EE = np.zeros(shape=(ml, ml), dtype=bool) plot_II = np.zeros(shape=(ml, ml), dtype=bool) plot_EI = np.zeros(shape=(ml, ml), dtype=bool) plot_IE = np.zeros(shape=(ml, ml), dtype=bool) for i in EElist: plot_EE[i[0], i[1]] = int(0) if i[0] != i[1]: # exclude self connections plot_EE[i[0], i[1]] = int(1) pre_exc.append(i[0]) post_exc.append(i[1]) assert len(pre_exc) == len(post_exc) for i in IIlist: plot_II[i[0], i[1]] = int(0) if i[0] != i[1]: plot_II[i[0], i[1]] = int(1) pre_inh.append(i[0]) post_inh.append(i[1]) for i in IElist: plot_IE[i[0], i[1]] = int(0) if i[0] != i[1]: # exclude self connections plot_IE[i[0], i[1]] = int(1) pre_inh.append(i[0]) post_inh.append(i[1]) for i in EIlist: plot_EI[i[0], i[1]] = int(0) if i[0] != i[1]: plot_EI[i[0], i[1]] = int(1) pre_exc.append(i[0]) post_exc.append(i[1]) plot_excit = plot_EI + plot_EE plot_inhib = plot_IE + plot_II assert len(pre_inh) == len(post_inh) num_exc = [i for i, e in enumerate(plot_excit) if sum(e) > 0] num_inh = [y for y, i in enumerate(plot_inhib) if sum(i) > 0] # the network is dominated by inhibitory neurons, which is unusual for modellers. assert num_inh > num_exc assert np.sum(plot_inhib) > np.sum(plot_excit) assert len(num_exc) < ml assert len(num_inh) < ml # # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections) nproc = sim.num_processes() nproc = 8 host_name = socket.gethostname() node_id = sim.setup(timestep=0.01, min_delay=1.0) #, **extra) print("Host #%d is on %s" % (node_id + 1, host_name)) rng = NumpyRNG(seed=64754) all_cells = sim.Population( len(index_exc) + len(index_inh), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0)) pop_exc = sim.PopulationView(all_cells, index_exc) pop_inh = sim.PopulationView(all_cells, index_inh) for pe in pop_exc: pe = all_cells[pe] r = random.uniform(0.0, 1.0) pe.set_parameters(a=0.02, b=0.2, c=-65 + 15 * r, d=8 - r**2, i_offset=0) for pi in index_inh: pi = all_cells[pi] r = random.uniform(0.0, 1.0) pi.set_parameters(a=0.02 + 0.08 * r, b=0.25 - 0.05 * r, c=-65, d=2, i_offset=0) NEXC = len(num_exc) NINH = len(num_inh) exc_syn = sim.StaticSynapse(weight=wg, delay=delay_distr) assert np.any(internal_conn_ee.conn_list[:, 0]) < ee_srcs.size prj_exc_exc = sim.Projection(all_cells, all_cells, internal_conn_ee, exc_syn, receptor_type='excitatory') prj_exc_inh = sim.Projection(all_cells, all_cells, internal_conn_ei, exc_syn, receptor_type='excitatory') inh_syn = sim.StaticSynapse(weight=wg, delay=delay_distr) delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng) prj_inh_inh = sim.Projection(all_cells, all_cells, internal_conn_ii, inh_syn, receptor_type='inhibitory') prj_inh_exc = sim.Projection(all_cells, all_cells, internal_conn_ie, inh_syn, receptor_type='inhibitory') inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng) ext_Connector = OneToOneConnector(callback=progress_bar) ext_syn = StaticSynapse(weight=JE, delay=dt) ''' print("%d Connecting excitatory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JE, delay)) E_to_E = Projection(E_net, E_net, connector, E_syn, receptor_type="excitatory") print("E --> E\t\t", len(E_to_E), "connections") I_to_E = Projection(I_net, E_net, connector, I_syn, receptor_type="inhibitory") print("I --> E\t\t", len(I_to_E), "connections") input_to_E = Projection(expoisson, E_net, ext_Connector, ext_syn, receptor_type="excitatory") print("input --> E\t", len(input_to_E), "connections") print("%d Connecting inhibitory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JI, delay)) E_to_I = Projection(E_net, I_net, connector, E_syn, receptor_type="excitatory") print("E --> I\t\t", len(E_to_I), "connections") I_to_I = Projection(I_net, I_net, connector, I_syn, receptor_type="inhibitory") print("I --> I\t\t", len(I_to_I), "connections") input_to_I = Projection(inpoisson, I_net, ext_Connector, ext_syn, receptor_type="excitatory") print("input --> I\t", len(input_to_I), "connections") ''' def prj_change(prj, wg): prj.setWeights(wg) prj_change(prj_exc_exc, wg) prj_change(prj_exc_inh, wg) prj_change(prj_inh_exc, wg) prj_change(prj_inh_inh, wg) def prj_check(prj): for w in prj.weightHistogram(): for i in w: print(i) prj_check(prj_exc_exc) prj_check(prj_exc_inh) prj_check(prj_inh_exc) prj_check(prj_inh_inh) #print(rheobase['value']) #print(float(rheobase['value']),1.25/1000.0) '''Old values that worked noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_exc.inject(noise) #1000.0 pA noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_inh.inject(noise) #1750.0 pA ''' noise = sim.NoisyCurrentSource(mean=0.74 / 1000.0, stdev=4.00 / 1000.0, start=0.0, stop=2000.0, dt=1.0) pop_exc.inject(noise) #1000.0 pA noise = sim.NoisyCurrentSource(mean=1.440 / 1000.0, stdev=4.00 / 1000.0, start=0.0, stop=2000.0, dt=1.0) pop_inh.inject(noise) ## # Setup and run a simulation. Note there is no current injection into the neuron. # All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes ## sim = pyNN.neuron arange = np.arange import re all_cells.record(['v', 'spikes']) # , 'u']) all_cells.initialize(v=-65.0, u=-14.0) # === Run the simulation ===================================================== tstop = 2000.0 sim.run(tstop) data = None data = all_cells.get_data().segments[0] if not os.path.exists("pickles"): os.mkdir("pickles") #print(len(data.analogsignals[0].times)) with open('pickles/qi' + str(wg) + '.p', 'wb') as f: pickle.dump(data, f) # make data none or else it will grow in a loop all_cells = None data = None noise = None
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
#misc.set_cell_params(pop_1, cellparams) pop_2 = sim.Population(size=4, cellclass=sim.IF_curr_exp(), label="2_hidden") pop_2.set(v_thresh=0.1) #misc.set_cell_params(pop_2, cellparams) #pop_2.set(i_offset=s[label]['v_thresh']) # this projection / pop_0 is only used to monitor the input spikes (actually not needed for MLP network) input_proj = sim.Projection(input_pop, pop_0, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=3, delay=1)) if INHIBITORY: inhibitory_connections_1, exitatory_connections_1 = misc.read_connections( p1) inhibitory_connector_1 = sim.FromListConnector( inhibitory_connections_1, column_names=["i", "j", "delay", "weight"]) exitatory_connector_1 = sim.FromListConnector( exitatory_connections_1, column_names=["i", "j", "delay", "weight"]) inhibitory_proj_1 = sim.Projection(pop_0, pop_1, inhibitory_connector_1, receptor_type='inhibitory') exitatory_proj_1 = sim.Projection(pop_0, pop_1, exitatory_connector_1, receptor_type='excitatory') inhibitory_connections_2, exitatory_connections_2 = misc.read_connections( p2) inhibitory_connector_2 = sim.FromListConnector( inhibitory_connections_2, column_names=["i", "j", "delay", "weight"])
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()
'connected_chip_coords':connected_chip_coords, 'connected_chip_edge':link, 'unique_id': 'R', "polarity": p.ExternalRetinaDevice.DOWN_POLARITY}, label='input_pol_1down') subsampled = p.Population(subsample_size*subsample_size, # size p.IF_curr_exp, # Neuron Type cell_params, # Neuron Parameters label="Input") # Label subsampled.initialize('v', -75) subsampled.set_mapping_constraint({'x':0,'y':1}) #subsampled.record() # sends spikes to the visualiser (use parameters = 32) list_input = retina_lib.subSamplerConnector2D(128,subsample_size,.2,1) #print "input list is :" #print list_input p1_up = p.Projection(input_pol_1_up, subsampled, p.FromListConnector(list_input), label='subsampling projection') p2_down = p.Projection(input_pol_1_down, subsampled, p.FromListConnector(list_input), label='subsampling projection') p.run(runtime) # Simulation time p.end()
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
stdp_projection = sim.Projection(statePopulation, actorPopulation, sim.OneToOneConnector(), synapse_type=stdp_model) state_projection = sim.Projection(stateSpikeInjector, statePopulation, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=2)) actorProjection = sim.Projection(actorSpikeInjector, actorPopulation, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=0)) connectionList = [] for step in range(numberOfSteps-1): for action in range(numberOfActions): connectionList.append((action, action + numberOfActions)) moves_projection = sim.Projection(actorPopulation, actorPopulation, sim.FromListConnector(connectionList), synapse_type=sim.StaticSynapse(weight=5, delay=2)) connectionList = [] currentMove = 0 for step in range(numberOfSteps): for action in range(numberOfActions): connectionList.append((step, currentMove)) currentMove += 1 first_spike_trigger_projection = sim.Projection(firstSpikeTrigger, statePopulation, sim.FromListConnector(connectionList), synapse_type=sim.StaticSynapse(weight=5, delay=2)) statePopulation.record(["spikes", "v"]) actorPopulation.record(["spikes", "v"])
delay = 17 loopConnections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) loopConnections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0, 1050]]} populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) projections.append(p.Projection(populations[0], populations[0], p.FromListConnector(loopConnections))) projections.append(p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record_v() populations[0].record_gsyn() populations[0].record() p.run(runtime) v = None gsyn = None spikes = None v = populations[0].get_v(compatible_output=True) gsyn = populations[0].get_gsyn(compatible_output=True)
def train(label, untrained_weights=None): organisedStim = {} labelSpikes = [] spikeTimes = generate_data(label) for i in range(output_size): labelSpikes.append([]) labelSpikes[label] = [(input_size - 1) * v_co + 1, (input_size - 1) * v_co * 2 + 1, (input_size - 1) * v_co * 3 + 1] if untrained_weights == None: untrained_weights = RandomDistribution('uniform', low=wMin, high=wMaxInit).next(input_size * output_size) #untrained_weights = RandomDistribution('normal_clipped', mu=0.1, sigma=0.05, low=wMin, high=wMaxInit).next(input_size*output_size) untrained_weights = np.around(untrained_weights, 3) #saveWeights(untrained_weights, 'untrained_weightssupmodel1traj') print("init!") print "length untrained_weights :", len(untrained_weights) if len(untrained_weights) > input_size: training_weights = [[0 for j in range(output_size)] for i in range(input_size) ] #np array? size 1024x25 k = 0 for i in range(input_size): for j in range(output_size): training_weights[i][j] = untrained_weights[k] k += 1 else: training_weights = untrained_weights connections = [] for n_pre in range(input_size): # len(untrained_weights) = input_size for n_post in range( output_size ): # len(untrained_weight[0]) = output_size; 0 or any n_pre connections.append((n_pre, n_post, training_weights[n_pre][n_post], __delay__)) #index runTime = int(max(max(spikeTimes))) + 100 ##################### sim.setup(timestep=1) #def populations layer1 = sim.Population(input_size, sim.SpikeSourceArray, {'spike_times': spikeTimes}, label='inputspikes') layer2 = sim.Population(output_size, sim.IF_curr_exp, cellparams=cell_params_lif, label='outputspikes') supsignal = sim.Population(output_size, sim.SpikeSourceArray, {'spike_times': labelSpikes}, label='supersignal') #def learning rule stdp = sim.STDPMechanism( weight=untrained_weights, #weight=0.02, # this is the initial value of the weight #delay="0.2 + 0.01*d", timing_dependence=sim.SpikePairRule(tau_plus=tauPlus, tau_minus=tauMinus, A_plus=aPlus, A_minus=aMinus), weight_dependence=sim.MultiplicativeWeightDependence(w_min=wMin, w_max=wMax), #weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=0.4), dendritic_delay_fraction=1.0) #def projections stdp_proj = sim.Projection(layer1, layer2, sim.FromListConnector(connections), synapse_type=stdp) inhibitory_connections = sim.Projection( layer2, layer2, sim.AllToAllConnector(allow_self_connections=False), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory') stim_proj = sim.Projection(supsignal, layer2, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse( weight=stimWeight, delay=__delay__)) layer1.record(['spikes']) layer2.record(['v', 'spikes']) supsignal.record(['spikes']) sim.run(runTime) print("Weights:{}".format(stdp_proj.get('weight', 'list'))) weight_list = [ stdp_proj.get('weight', 'list'), stdp_proj.get('weight', format='list', with_address=False) ] neo = layer2.get_data(["spikes", "v"]) spikes = neo.segments[0].spiketrains v = neo.segments[0].filter(name='v')[0] neostim = supsignal.get_data(["spikes"]) print(label) spikestim = neostim.segments[0].spiketrains neoinput = layer1.get_data(["spikes"]) spikesinput = neoinput.segments[0].spiketrains pplt.Figure(pplt.Panel(v, ylabel="Membrane potential (mV)", xticks=True, yticks=True, xlim=(0, runTime)), pplt.Panel(spikesinput, xticks=True, yticks=True, markersize=2, xlim=(0, runTime)), pplt.Panel(spikestim, xticks=True, yticks=True, markersize=2, xlim=(0, runTime)), pplt.Panel(spikes, xticks=True, xlabel="Time (ms)", yticks=True, markersize=2, xlim=(0, runTime)), title="Training" + str(label), annotations="Training" + str(label)).save('plot1/' + str(trylabel) + str(label) + '_training.png') sim.end() return weight_list[1]
A_minus=0.001) weight_rule = sim.AdditiveWeightDependence(w_max=5.0, w_min=-5.0) stdp_model = sim.STDPMechanism(timing_dependence=timing_rule, weight_dependence=weight_rule, weight=2, delay=1) connectionList = [] for step in range(numberOfSteps - 1): for action in range(numberOfActions): connectionList.append((action, action + numberOfActions)) moves_projection = sim.Projection(post_pop, post_pop, sim.FromListConnector(connectionList), synapse_type=sim.StaticSynapse(weight=5, delay=2)) stdp_projection = sim.Projection(pre_pop, post_pop, sim.OneToOneConnector(), synapse_type=stdp_model) input_projection1 = sim.Projection(input1, pre_pop, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=5, delay=2)) input_projection2 = sim.Projection(input2,
def setupLayerAN(params, settings, neuronModel, cell_params, popClassActivation, popPoissionNoiseSource, populationsPN, populationsAN, projectionsPNAN): #create an Association Neuron AN cluster population per class #this will be fed by: #1) PN clusters via plastic synapses #2) Class activation to innervate the correct AN cluster for a given input #3) laterally inhibit between AN clusters numClasses = params['NUM_CLASSES'] anClusterSize = params['CLUSTER_SIZE'] * params['NETWORK_SCALE'] learning = settings['LEARNING'] for an in range(numClasses): popName = 'popClusterAN_' + str(an) popClusterAN = spynnaker.Population(anClusterSize, neuronModel, cell_params, label=popName) populationsAN.append(popClusterAN) #connect neurons in every PN popn to x% (e.g 50%) neurons in #this AN cluster for pn in range(len(populationsPN)): if learning: projLabel = 'Proj_PN' + str(pn) + '_AN' + str(an) projClusterPNToClusterAN = connectClusterPNtoAN( params, populationsPN[pn], popClusterAN, projLabel) projectionsPNAN.append(projClusterPNToClusterAN) #keep handle #to use later for saving off weights at end of learning else: #Without plasticity, create PNAN FromList connectors #using weights saved during learning stage connections = utils.loadListFromFile( getWeightsFilename(settings, 'PNAN', pn, an)) #print 'Loaded weightsList[',pn,',',an,']',connections #print np.shape(connections) projClusterPNToClusterAN = spynnaker.Projection( populationsPN[pn], popClusterAN, spynnaker.FromListConnector(connections), target='excitatory') if learning: #use the class activity input neurons to create correlated #activity during learning in the corresponding class cluster weight = params['WEIGHT_CLASS_ACTIVITY_TO_CLUSTER_AN'] connections = utils.fromList_SpecificNeuronToAll( an, anClusterSize, weight, params['MIN_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN'], params['MAX_DELAY_CLASS_ACTIVITY_TO_CLUSTER_AN']) projClassActivityToClusterAN = spynnaker.Projection( popClassActivation, popClusterAN, spynnaker.FromListConnector(connections), target='excitatory') #connect each AN cluster to inhibit every other AN cluster utils.createInterPopulationWTA(populationsAN, params['WEIGHT_WTA_AN_AN'], params['DELAY_WTA_AN_AN'], float(params['CONNECTIVITY_WTA_AN_AN']))