def build_network_connections(spikeSequence, data, inputLayer, outputLayer): # Get generated spike sequence for each layer inputSpikeSequence = spikeSequence[0] outputSpikeSequence = spikeSequence[1] # Total number of data items totalNumberOfDataItems = len(data) # Loop through all data items for eachWine in range(0, totalNumberOfDataItems): dataItem = data[eachWine] # === Presynaptic layer == # Gets presynaptic connections for each data item inputConnector = generate_feature_connections(dataItem, eachWine) inputFromListConnector = sim.FromListConnector(inputConnector) sim.Projection(inputSpikeSequence, inputLayer, inputFromListConnector, receptor_type='excitatory') # === Postsynaptic layer === outputClass = dataItem[0] - 1 # -1 so the classes are from 0, 1 and 2. outputConnector = [(eachWine, outputClass, FIRING_WEIGHT, TIME_STEP)] outputFromListConnector = sim.FromListConnector(outputConnector) sim.Projection(outputSpikeSequence, outputLayer, outputFromListConnector, receptor_type='excitatory')
def conv_pops(pop1, pop2, w): in_size = int(np.sqrt(pop1.size)) out_size = int(np.sqrt(pop2.size)) conn_exci, conn_inhi = conv_conn(in_size, out_size, w) if len(conn_exci)>0: p.Projection(pop1, pop2, p.FromListConnector(conn_exci), target='excitatory') if len(conn_inhi)>0: p.Projection(pop1, pop2, p.FromListConnector(conn_inhi), target='inhibitory') return
def fcLayer_Proj(pre_pop, cnn_fcLayer, cell_params, num_label): exci_conn, inhi_conn = fcLayer_Connect(cnn_fcLayer, num_label) post_pop = sim.Population(num_label, sim.IF_curr_exp, cell_params) if len(exci_conn) > 0: sim.Projection(pre_pop, post_pop, sim.FromListConnector(exci_conn), target='excitatory') if len(inhi_conn) > 0: sim.Projection(pre_pop, post_pop, sim.FromListConnector(inhi_conn), target='inhibitory') return post_pop
def out_pops(pop_list, pop2, w_layer): in_size = pop_list[0].size out_size = pop2.size for i in range(len(pop_list)): w = w_layer[:,i*in_size:(i+1)*in_size] conn_exci, conn_inhi = out_conn(w) if len(conn_exci)>0: p.Projection(pop_list[i], pop2, p.FromListConnector(conn_exci), target='excitatory') if len(conn_inhi)>0: p.Projection(pop_list[i], pop2, p.FromListConnector(conn_inhi), target='inhibitory') return
def convLayer_Proj(pre_pop, cnn_convLayer, cell_params): output_depth = cnn_convLayer.num_Filters output_size = (len(cnn_convLayer.input_volume[0]) - cnn_convLayer.filter_Size + 2*cnn_convLayer.pad)/cnn_convLayer.stride + 1 post_pop = sim.Population(np.prod((output_depth, output_size, output_size)), sim.IF_curr_exp, cell_params) exci_conn, inhi_conn = convLayer_Connect(cnn_convLayer) if len(exci_conn) > 0: sim.Projection(pre_pop, post_pop, sim.FromListConnector(exci_conn), target='excitatory') if len(inhi_conn) > 0: sim.Projection(pre_pop, post_pop, sim.FromListConnector(inhi_conn), target='inhibitory') return post_pop
def pool_pops(pop1, pop2, w): in_size = int(np.sqrt(pop1.size)) out_size = int(np.sqrt(pop2.size)) conn_exci = pool_conn(in_size, out_size, w) if len(conn_exci)>0: p.Projection(pop1, pop2, p.FromListConnector(conn_exci), target='excitatory') return
def test_create_with_homogeneous_common_properties(self): with self.assertRaises(ValueError): # create synapse type with heterogeneous common parameters fromlist = sim.FromListConnector(conn_list=[ (0, 0, 10., 100.), (1, 1, 10., 200.)], column_names=["weight", "Wmax"]) prj = sim.Projection(self.p1, self.p2, fromlist, synapse_type=self.native_synapse_type())
def poolLayer_Proj(pre_pop, cnn_poolLayer, cell_params): conn = poolLayer_Connect(cnn_poolLayer) output_depth = len(cnn_poolLayer.input_volume) output_size = (len(cnn_poolLayer.input_volume[0]) - cnn_poolLayer.filter_Size)/cnn_poolLayer.stride + 1 post_pop = sim.Population(np.prod((output_depth, output_size, output_size)), sim.IF_curr_exp, cell_params) if len(conn) > 0: sim.Projection(pre_pop, post_pop, sim.FromListConnector(conn), target='excitatory') return post_pop
def build_testing_connections(testSpikeSources, data, testInputLayer): numberDataItems = len(data) # Loop through all data elements (89 for wine test data) for element in range(0, numberDataItems): dataItem = data[element] # Get connections for each data item testConnector = generate_feature_connections(dataItem, element) testFromListConnector = sim.FromListConnector(testConnector) sim.Projection(testSpikeSources, testInputLayer, testFromListConnector, receptor_type='excitatory')
def connect_testing_layers(inputLayer, outputLayer, synapses): connector = [] for synapseOffset in range(0, len(synapses)): fromNeuron = synapses[synapseOffset][0] toNeuron = synapses[synapseOffset][1] weight = synapses[synapseOffset][2] connector = connector + [(fromNeuron, toNeuron, weight, TIME_STEP)] testFromListConnector = sim.FromListConnector(connector) sim.Projection(inputLayer, outputLayer, testFromListConnector, receptor_type='excitatory')
label=label) # Set the rest of the specified variables, if any. for variable in s['variables']: if getattr(population, variable, None) is None: setattr(population, variable, s[label][variable]) if label != 'InputLayer': population.set(i_offset=s[label]['i_offset']) layers.append(population) print('assembly loaded') # ------ Load weights and delays -------- for i in range(len(layers) - 1): print('Loading connections for layer ' + str(layers[i].label)) filepath = os.path.join(layers_path, layers[i + 1].label) conn_list = read_from_file2list(filepath) exc_connector = sim.FromListConnector(conn_list[0]) pro_exc = sim.Projection(layers[i], layers[i + 1], connector=exc_connector, receptor_type='excitatory') if conn_list[1] != []: inh_connector = sim.FromListConnector(read_from_file2list(filepath)[1]) pro_inh = sim.Projection(layers[i], layers[i + 1], connector=inh_connector, receptor_type='inhibitory') print('connections loaded') # -------- Cell initialization ----------- #vars_to_record = ['spikes','v'] #if 'spikes' in vars_to_record:
spike_2_conn_for_2 = sim.Projection(spike_source_2, cann_pop[2:3], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.002, delay=0.1)) spike_2_conn_for_3 = sim.Projection(spike_source_3, cann_pop[3:4], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.002, delay=0.1)) spike_2_conn_for_4 = sim.Projection(spike_source_4, cann_pop[4:5], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.002, delay=0.1)) spike_2_conn_for_9 = sim.Projection(spike_source_9, cann_pop[9:10], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.002, delay=0.1)) cann_2_cann = sim.Projection( cann_pop, cann_pop, sim.FromListConnector(cann_connector, column_names=["weight"]), sim.StaticSynapse(weight=0.0001, delay=75)) cann_2_inh = sim.Projection(cann_pop, inhib_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=0.02, delay=0.1), receptor_type="excitatory") inh_2_cann = sim.Projection(inhib_pop, cann_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=0.2, delay=0.1), receptor_type="inhibitory") #spike_source.record('spikes')
spike_times = [1000., 2000.] cann_pop = sim.Population(n, sim.IF_cond_alpha(**cell_params), label = "cann_pop") inhib_pop = sim.Population(1, sim.IF_cond_alpha(**cell_params), label = "inhib_pop") spike_source = sim.Population(1, sim.SpikeSourceArray( spike_times = spike_times)) spike_2_conn = sim.Projection(spike_source, cann_pop[spiky:spiky+1], sim.AllToAllConnector(), sim.StaticSynapse(weight = 0.002, delay = 0.1)) cann_2_cann = sim.Projection(cann_pop, cann_pop, sim.FromListConnector(cann_connector, column_names=["weight"]), sim.StaticSynapse(weight = 0.0001, delay = 75)) cann_2_inh = sim.Projection(cann_pop, inhib_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight = 0.02, delay = 0.1), receptor_type = "excitatory") inh_2_cann = sim.Projection(inhib_pop, cann_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight = 0.2, delay = 0.1), receptor_type = "inhibitory") spike_source.record('spikes') cann_pop.record(('v','spikes')) inhib_pop.record(('v','spikes')) sim.run(5000.0)
fc0.initialize(**cellvalues) fc0.set(v_thresh=vth0) fc1 = sim.Population(w1.shape[0], fc_celltype) fc1.initialize(**cellvalues) fc1.set(v_thresh=vth1) #fc1.set(i_offset=b1) fc2 = sim.Population(10, fc_celltype) fc2.initialize(**cellvalues) fc2.set(v_thresh=vth2) #fc2.set(i_offset=b2) proj0 = sim.Projection(input_pop, fc0, connector=sim.FromListConnector(conns_0)) proj1 = sim.Projection(fc0, fc1, connector=sim.FromListConnector(conns_1)) proj2 = sim.Projection(fc1, fc2, connector=sim.FromListConnector(conns_2)) #input_pop.record('spikes') fc0.record(['spikes', 'v']) #fc1.record(['spikes','v']) #fc2.record(['spikes','v']) fc2.record(['spikes']) sim.run(duration - dt) #spiketrains_i = input_pop.get_data().segments[-1].spiketrains #spiketrains_0 = fc0.get_data().segments[-1].spiketrains #spiketrains_1 = fc1.get_data().segments[-1].spiketrains spiketrains_2 = fc2.get_data().segments[-1].spiketrains
stdp_weight = np.load('%s/weight_%d.npy' % (directory, (run_i - 1))) proj_stdp = p.Projection( #pop_input, pop_output, p.AllToAllConnector(weights = weight_distr), pop_input, pop_output, p.AllToAllConnector(weights=stdp_weight), synapse_dynamics=p.SynapseDynamics(slow=stdp_model)) for i in range(num_output): conn_list = list() for j in range(num_output): if i != j: conn_list.append((i, j, -18.1, 1.0)) p.Projection(pop_output, pop_output, p.FromListConnector(conn_list), target='inhibitory') for i in range(num_train * num_epo): p.Projection(TeachingPoission[i], pop_output, ee_connector, target='excitatory') #pop_input.record() pop_output.record() pre = proj_stdp.getWeights(format='array', gather=False) #print pre p.run(1.0 * num_epo * num_train * (dur_train + silence)) post = proj_stdp.getWeights(format='array', gather=False) np.save('%s/weight_%d.npy' % (directory, run_i), post) '''
# ====================================================================================================== # create interpopulation projections projections_inp_hiddenP = [] for idx, pop in enumerate(hidden_populations[:N_uninverted]): projection_inp_hiddenP = sim.Projection(input_populations[0], pop[0], sim.FixedProbabilityConnector(p_connect=Pconnect_input[idx]), sim.StaticSynapse(weight=weights_input[idx,0])) #input_weights[idx,0] [neuron.weights for x in range(hiddenP_size)] projections_inp_hiddenP.append(projection_inp_hiddenP) # ? is it necessary to store them in a list ? for idx, pop in enumerate(hidden_populations[N_uninverted:]): projection_inp_hiddenP = sim.Projection(input_populations[1], pop[0], sim.FixedProbabilityConnector(p_connect=Pconnect_input[idx+N_uninverted]), sim.StaticSynapse(weight=weights_input[idx+N_uninverted,0])) #input_weights[idx,0] [neuron.weights for x in range(hiddenP_size)] projections_inp_hiddenP.append(projection_inp_hiddenP) # ? is it necessary to store them in a list ? #projections_hiddenP_monitor for idx in range(N_res): connector = sim.FromListConnector(conn_list=[(x,idx) for x in range(hiddenPexc_size)]) projection=sim.Projection(hidden_populations[idx][0], monitor_population, connector, sim.StaticSynapse(weight=1.0)) projections_hiddenP_readout = [] connector = sim.AllToAllConnector() #FixedProbabilityConnector(p_connect=0.14) , delays=np.random.randint(6,72), rng=rng for idx0 in range(N_readouts): readout_pop = readout_neuron_populations[idx0] projections = [] for idx1 in range(N_res): pop0exc = hidden_populations[idx1][0] weight = weights_readout[idx0][idx1, 0] projection = sim.Projection(pop0exc, readout_pop, connector, sim.StaticSynapse(weight=weight)) projections.append(projection) projections_hiddenP_readout.append(projections)
def setup(self): # set up layers according to backend self.layers = [] if self.backend == 'spinnaker': spin_sim.setup(timestep=1.0, time_scale_factor=1.0, min_delay=1.0, max_delay=None) # set neuron hyperparameters # tau_m should not be set too high, because it can easily lead to an overflow ctx_parameters = {'cm': 1.0, 'i_offset': 0.0, 'tau_m': 100.0, 'tau_refrac': 0.0, 'v_reset': 0.0, 'v_rest': 0.0, 'v_thresh': 1.0} tc_parameters = ctx_parameters.copy() neuron_type = extra_models.IFCurDelta(**tc_parameters) for l in range(0,len(self.weights)): self.layers.append(spin_sim.Population(self.architecture[l+1], neuron_type, initial_values={'v': 0.0})) # set output layer threshold: must be set high enough s.t. output neurons do not spike, # must not be set too high to avoid overflow self.layers[-1].set(v_thresh=10000.0) elif self.backend == 'nest': nest_sim.setup(timestep=1.0, min_delay=1.0) # set neuron type, currently only supports iaf_psc_delta and one set of hyperparameters neuron_type = nest_sim.native_cell_type('iaf_psc_delta') for l in range(0, len(self.weights)-1): self.layers.append(nest_sim.Population(self.architecture[l+1], neuron_type(V_th=1.0, t_ref=0.0, V_min=-np.inf, C_m=1.0, V_reset=0.0, tau_m=10.0**10, E_L=0.0, I_e=0.0))) self.layers[l].initialize(V_m=0.0) # set up output layer seperately with infinite threshold self.layers.append(nest_sim.Population(self.architecture[-1], neuron_type(V_th=np.inf, t_ref=0.0, V_min=-np.inf, C_m=1.0, V_reset=0.0, tau_m=10.0 ** 10, E_L=0.0, I_e=0.0))) self.layers[-1].initialize(V_m=0.0) elif self.backend == 'pynn': raise Exception('Current implementation does not support native pynn types. ' 'Code after this exception acts as an example on how native pynn types' 'are used and can be modified. Additionally, the backend still needs to' 'be specified and is set to nest in the code below.') # the following out-commented lines show how a native pynn type would be used ''' nest_sim.setup(timestep=1.0, time_scale_factor=1.0, min_delay=1.0, max_delay=None) # conductive exponential neuron as an example ctx_parameters = {'cm': 1.0, 'e_rev_E': 0.0, 'e_rev_I': -65.0, 'i_offset': 0.0, 'tau_m': 10000.0, 'tau_refrac': 0.0, 'tau_syn_E': 0.01, 'tau_syn_I': 0.01, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -64.0} #tc_parameters = ctx_parameters.copy() neuron_type = sim.IF_cond_exp(**tc_parameters) for l in range(0,len(self.weights)): self.layers.append(sim.Population(self.architecture[l+1], neuron_type, initial_values={'v': 0.0})) # output layer should not spike self.layers[-1].set(v_thresh=np.inf) ''' else: raise Exception('backend not supported') # connect layers (input layer is connected to first in simulate by setting offsets for l in range(0, len(self.layers)-1): excitatory_connections = [] inhibitory_connections = [] # 1 and 2 for i in range(0, len(self.layers[l])): for j in range(0, len(self.layers[l+1])): if self.weights[l+1][i][j].detach().item() >= 0: excitatory_connections.append((i, j, self.weights[l+1][i][j].detach().item(),1.0)) else: inhibitory_connections.append((i, j, self.weights[l+1][i][j].detach().item(),1.0)) # when using NEST or native PyNN models, connect has to be called explicitly, when using # SpiNNaker connecting happens automatically if self.backend == 'pynn' or self.backend == 'nest': excitatory_connector = nest_sim.FromListConnector(excitatory_connections, column_names=["weight", "delay"]) excitatory_projection = nest_sim.Projection(self.layers[l], self.layers[l + 1], connector=excitatory_connector) excitatory_connector.connect(excitatory_projection) elif self.backend == 'spinnaker': excitatory_connector = spin_sim.FromListConnector(excitatory_connections, column_names=["weight", "delay"]) excitatory_projection = spin_sim.Projection(self.layers[l], self.layers[l + 1], connector=excitatory_connector) # when using NEST or native PyNN models, connect has to be called explicitly, when using # SpiNNaker connecting happens automatically if self.backend == 'pynn' or self.backend == 'nest': inhibitory_connector = nest_sim.FromListConnector(inhibitory_connections, column_names=["weight", "delay"]) inhibitory_projection = nest_sim.Projection(self.layers[l], self.layers[l + 1], inhibitory_connector, receptor_type='inhibitory') inhibitory_connector.connect(inhibitory_projection) elif self.backend == 'spinnaker': inhibitory_connector = spin_sim.FromListConnector(inhibitory_connections, column_names=["weight", "delay"]) inhibitory_projection = spin_sim.Projection(self.layers[l], self.layers[l + 1], inhibitory_connector, receptor_type='inhibitory') # set biases (constant input currents) for l in range(0,len(self.layers)): for i in range(0,len(self.layers[l])): # use i_offset on spynnaker instead of DCSource offset = self.biases[l][i].detach().item() if self.backend == 'nest': self.layers[l][i:i+1].set(I_e=offset) elif self.backend == 'pynn' or self.backend=='spinnaker': self.layers[l][i:i+1].set(i_offset=offset) # record the potentials of the last layer if self.backend == 'nest' or self.backend == 'pynn': self.layers[-1].record('V_m') elif self.backend == 'spinnaker': self.layers[-1].record('v')
t2 = [[2,3,4,8],[2,4,6,8]] t1 = [2,12] input_celltype = sim.SpikeSourceArray(spike_times=t2) fc_celltype = sim.IF_cond_exp(**cellparams) pop0 = sim.Population(2,input_celltype) pop1 = sim.Population(1, fc_celltype) pop1.initialize(**cellvalues) #pop1.set(i_offset=b) pop1.record(['spikes','v']) pop0.record(['spikes']) # create synapsis conn = sim.FromListConnector(w2) pro = sim.Projection(pop0, pop1, connector=conn) sim.run(duration) mem = pop1.get_data().segments[-1].analogsignals[0] sp0 = pop0.get_data().segments[-1].spiketrains sp1 = pop1.get_data().segments[-1].spiketrains from pyNN.utility.plotting import Figure, Panel Figure( Panel(mem, ylabel="Membrane potential (mV)", xticks=True, xlabel="Time (ms)", yticks=True))
# Create list of connections cortical_inh_exc_connections = create_cortical_to_cortical_connection( cortical_neurons_inh, cortical_neurons_exc, orientations_inh, phases_inh, orientations_exc, phases_exc, orientation_sigma, phase_sigma, g_exc, n_pick, target_type_excitatory=False) # Make the list a connector cortical_inh_exc_connector = simulator.FromListConnector( cortical_inh_exc_connections, column_names=["weight", "delay"]) # Projections #cortical_inh_exc_projection = simulator.Projection(cortical_neurons_inh, cortical_neurons_exc, # cortical_inh_exc_connector, receptor_type='inhibitory') ## Now we create the excitatory connections if cortical_excitatory_feedback: # Create list of connectors cortical_exc_exc_connections = create_cortical_to_cortical_connection( cortical_neurons_exc, cortical_neurons_exc, orientations_exc, phases_exc, orientations_exc,
for j in range(weights[layer].shape[0]): if float(weights[layer][j, i]) < 0.0: inh_synapses.append([i, j, -1.0 * weights[layer][j, i], delay]) else: exc_synapses.append([i, j, weights[layer][j, i], delay]) pops.append(sim.Population(weights[layer].shape[0], fc_celltype)) vth = v_th - biases[layer] vth[vth < 0.0] = 0.001 pops[layer + 1].set(v_thresh=vth) sim.Projection(pops[layer], pops[layer + 1], connector=sim.FromListConnector(inh_synapses), receptor_type='inhibitory') sim.Projection(pops[layer], pops[layer + 1], connector=sim.FromListConnector(exc_synapses), receptor_type='excitatory') pops[-1].record(['spikes']) pops[0].record(['spikes']) pops[1].record(['spikes', 'v']) num_to_test = 10 acc = 0.0 num_timesteps = duration / dt
#spike_2_conn_for_9 = sim.Projection(spike_source_9, hd_cann_pop[9:10], sim.OneToOneConnector(), # sim.StaticSynapse(weight = 0.002, delay = 0.1)) pos_spikes = sim.Projection(pos_spike_src, pos_rot_conj[3:4], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.2, delay=0.1)) neg_spikes = sim.Projection(neg_spike_src, neg_rot_conj[4:5], sim.OneToOneConnector(), sim.StaticSynapse(weight=0.2, delay=0.1)) # Connections/ Projections hd_cann_2_hd_cann = sim.Projection( hd_cann_pop, hd_cann_pop, sim.FromListConnector(hd_cann_connector, column_names=["weight"]), sim.StaticSynapse(weight=0.0001, delay=75)) hd_cann_2_inh = sim.Projection(hd_cann_pop, inhib_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=0.02, delay=0.1), receptor_type="excitatory") inh_2_hd_cann = sim.Projection(inhib_pop, hd_cann_pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=0.5, delay=0.1), receptor_type="inhibitory") for i in range(n):
target='inhibitory') elif sim_test == 'spin': p.set_number_of_neurons_per_core("IF_curr_exp", 127) pop_poisson = p.Population(input_size * input_size, p.SpikeSourceArray, {'spike_times': spike_source_data}) ee_connector = p.OneToOneConnector(weights=3.0) pop_input = p.Population(input_size * input_size, p.IF_curr_exp, cell_params_lif) p.Projection(pop_poisson, pop_input, ee_connector, target='excitatory') pop_output = p.Population(num_output, p.IF_curr_exp, cell_params_lif) conn_list_exci = allToall2ConnectList(trained_weights, 1.0) conn_list_inhi = allToall2ConnectList(negtive_weights, 1.0) p.Projection(pop_input, pop_output, p.FromListConnector(conn_list_exci), target='excitatory') p.Projection(pop_input, pop_output, p.FromListConnector(conn_list_inhi), target='inhibitory') ''' for i in range(num_output): conn_list = list() for j in range(num_output): #if np.ceil(i/num_digit) != np.ceil(j/num_digit): if i!= j: conn_list.append((i, j, -1.1, 1.0)) #-1.1 p.Projection(pop_output, pop_output, p.FromListConnector(conn_list), target='inhibitory') print 'WTA:, ', i '''
'cm': 0.2, 'v_offset': -63.0, 'e_rev_Na': 50.0, 'e_rev_K': -90.0, 'e_rev_leak': -65.0, 'e_rev_E': 0.0, 'e_rev_I': -80.0, 'tau_syn_E': 10.0, 'tau_syn_I': 2.0, 'i_offset': 0.0, }) pop_cond_exp.record(["spikes", "v"]) sim.Projection(source, pop_cond_exp, connector=sim.FromListConnector([(0, 0, 0.1, 0.1)])) sim.run(1000.0) print "Conductance based exponential HH neuron" print pop_cond_exp.get_data().segments[0].spiketrains voltage_trace = pop_cond_exp.get_data().segments[0].analogsignalarrays[0] n = len(voltage_trace) arr = np.zeros((n, 2)) arr[:, 0] = np.linspace(0, timestep * (n - 1), n) arr[:, 1] = voltage_trace[:, 0] np.savetxt("hh_trace_pynn.csv", arr, delimiter=",") sim.end()