def connect(self): # connect populations self.injection = pynn.Projection(self.sources, self.columns, pynn.FixedProbabilityConnector( 0.02, weights=0.0033 * 2), target='excitatory', rng=pynn.random.NumpyRNG(seed=5337)) self.recurrent_excitation = pynn.Projection( self.columns, self.columns, pynn.OneToOneConnector(weights=0.01 * 2), target='excitatory') self.lateral_inhibition = pynn.Projection( self.columns, self.columns, pynn.DistanceDependentProbabilityConnector('d < 10', weights=0.004 * 2), target='inhibitory', rng=pynn.random.NumpyRNG(seed=5337)) self.global_inhibition = pynn.Projection( self.inhibitory_pool, self.columns, pynn.FixedProbabilityConnector(0.8, weights=0.0012 * 2), target='inhibitory', rng=pynn.random.NumpyRNG(seed=5337)) self.forward_inhibition = pynn.Projection( self.sources, self.inhibitory_pool, pynn.FixedProbabilityConnector(0.8, weights=0.0035), target='excitatory', rng=pynn.random.NumpyRNG(seed=5337))
def _connect(self): '''Connect populations.''' self._proj = sim.Projection(self._source_pop, self._target_pop, sim.FixedProbabilityConnector(self._p), rng=self._rng)
def getConnectorType(conn_type, ff_prob=None, lat_prob=None): """ For getting the feed-forward and lateral connection types. Arguments: conn_type, str, choices = ['all_to_all', 'fixed_prob', 'one_of_each'] ff_prob, float, probability of connection for feed-forward lat_prob, float, probability of connection for lateral Returns: ff_conn, lat_conn """ if conn_type == 'all_to_all': ff_conn = pynn.AllToAllConnector() lat_conn = pynn.AllToAllConnector(allow_self_connections=False) elif conn_type == 'fixed_prob': if (ff_prob == None) or (lat_prob == None): print(dt.datetime.now().isoformat() + ' ERROR: ' + 'One of the connections probabilities is "None".') sys.exit(2) else: ff_conn = pynn.FixedProbabilityConnector( ff_prob, rng=pynn.random.NumpyRNG(seed=1798)) lat_conn = pynn.FixedProbabilityConnector( lat_prob, allow_self_connections=False, rng=pynn.random.NumpyRNG(seed=1916)) elif conn_type == 'one_of_each': if ff_prob == None: print(dt.datetime.now().isoformat() + ' ERROR: ' + 'Feed forwards connections probabilities is "None".') sys.exit(2) else: ff_conn = pynn.FixedProbabilityConnector( ff_prob, rng=pynn.random.NumpyRNG(seed=1798)) lat_conn = pynn.AllToAllConnector(allow_self_connections=False) else: print(dt.datetime.now().isoformat() + ' ERROR: ' + 'Unrecognised connection type.') sys.exit(2) return ff_conn, lat_conn
def connect(self): """Setup connections between populations""" params = self.parameters.projections # generate weights with normal distributed jitter and set up stimulus w = params.stimulus.weight + np.random.normal( 0, params.stimulus.jitter, len(self.columns)) stimulus_connector = pynn.OneToOneConnector(weights=w) pynn.Projection(self.stimulus, self.columns, stimulus_connector) # projection to accumulate/count the number of active columns accumulation_connector = pynn.AllToAllConnector( weights=params.accumulation.weight) pynn.Projection(self.columns, self.kill_switch, accumulation_connector) # projection to inhibit all columns inhibition_connector = pynn.AllToAllConnector( weights=params.inhibition.weight) pynn.Projection(self.kill_switch, self.columns, inhibition_connector, target='inhibitory') # forward inhibition forward_inhibition_connector = pynn.FixedProbabilityConnector( params.forward_inhibition.probability, weights=params.forward_inhibition.weight) pynn.Projection(self.stimulus, self.columns, forward_inhibition_connector, target='inhibitory') # calculate connectivity matrix n_columns = self.parameters.populations.columns.size n_inputs = self.parameters.config.input_size self.connections = (np.random.uniform(0, 1, n_columns * n_inputs) > 0.60).reshape(len(self.columns), n_inputs).astype(np.int64) self.permanences = np.random.normal(.3, .05, n_columns * n_inputs).reshape( len(self.columns), n_inputs)
def test(): if not HAVE_H5PY and HAVE_NEST: raise SkipTest sim.setup() p1 = sim.Population(10, sim.IF_cond_exp(v_rest=-65, tau_m=lambda i: 10 + 0.1 * i, cm=RD('normal', (0.5, 0.05))), label="population_one") p2 = sim.Population(20, sim.IF_curr_alpha(v_rest=-64, tau_m=lambda i: 11 + 0.1 * i), label="population_two") prj = sim.Projection(p1, p2, sim.FixedProbabilityConnector(p_connect=0.5), synapse_type=sim.StaticSynapse(weight=RD( 'uniform', [0.0, 0.1]), delay=0.5), receptor_type='excitatory') net = Network(p1, p2, prj) export_to_sonata(net, "tmp_serialization_test", overwrite=True) net2 = import_from_sonata("tmp_serialization_test/circuit_config.json", sim) for orig_population in net.populations: imp_population = net2.get_component(orig_population.label) assert orig_population.size == imp_population.size for name in orig_population.celltype.default_parameters: assert_array_almost_equal(orig_population.get(name), imp_population.get(name), 12) w1 = prj.get('weight', format='array') prj2 = net2.get_component(asciify(prj.label).decode('utf-8') + "-0") w2 = prj2.get('weight', format='array') assert_array_almost_equal(w1, w2, 12)
def set_synapses(self, conn_type, sim_params, E_neurons, I_neurons, N_inh, conn_types, verbose): syn = {} proj = {} verbose = True if verbose: print('Building %s synapses..' % conn_types[conn_type]) weight = sim_params['w_{}'.format(conn_types[conn_type])] delay = sim_params['s_{}'.format(conn_types[conn_type])] syn[conn_types[conn_type]] = sim.StaticSynapse(delay=delay) if conn_types[ conn_type][:3] == 'exc': #string slicing, this co is TO exc pre_neurons = E_neurons receptor_type = 'excitatory' else: pre_neurons = I_neurons #TO inh receptor_type = 'inhibitory' if conn_types[conn_type][-3:] == 'exc': #FROM exc post_neurons = E_neurons else: post_neurons = I_neurons #FROM inh sparseness = sim_params['c_{}'.format(conn_types[conn_type])] proj[conn_types[conn_type]] = sim.Projection( pre_neurons, post_neurons, connector=sim.FixedProbabilityConnector(sparseness, rng=sim.NumpyRNG(seed=42)), synapse_type=syn[conn_types[conn_type]], receptor_type=receptor_type) bw = sim_params['b_{}'.format(conn_types[conn_type])] angle_pre = 1. * np.arange(proj[conn_types[conn_type]].pre.size) angle_post = 1. * np.arange(proj[conn_types[conn_type]].post.size) w_ij = self.tuning_function(angle_pre[:, np.newaxis], angle_post[np.newaxis, :], bw, N_inh) * weight proj[conn_types[conn_type]].set(weight=w_ij) return proj
p.IF_curr_exp, {}, label="reservoir") ###################### ###### Synapses ####### stat_syn_res = p.StaticSynapse(weight=5.0, delay=1) stat_syn_input = p.StaticSynapse(weight=50.0, delay=1) stat_syn_rout = p.StaticSynapse(weight=0.0, delay=1) ###################### ###### Connections ####### res_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng) inp_conn = p.AllToAllConnector() rout_conn = p.AllToAllConnector() connections = {} connections['r2r'] = p.Projection(reservoir, reservoir, res_conn, synapse_type=stat_syn_res, receptor_type='excitatory') connections['inp2r'] = p.Projection(input_neurons, reservoir, inp_conn, synapse_type=stat_syn_input,
def callback(data_input): #==================================================================== # Unpacking the Joint Angle Message #==================================================================== global message message = data_input.degree rospy.loginfo('=====> received joint angle in degree %r', message) print message if type(message) != int: input_rates = list(message) n_input_neurons = len(input_rates) else: input_rates = message n_input_neurons = 1 #msg_list= [int(msg.encode('hex'),16) for msg in message] timer = Timer() dt = 0.1 p.setup(timestep=dt) # 0.1ms #==================================================================== # Defining the LSM #==================================================================== n_res=2000 w_exc_b=0.2 w_inh_b=-0.8 rout_w_exc=20 rout_w_inh=-80 n_readout_neurons = 2 n_reservoir_neurons = n_res n_res = n_reservoir_neurons exc_rate = 0.8 # percentage of excitatory neurons in reservoir n_exc = int(round(n_reservoir_neurons*exc_rate)) n_inh = n_reservoir_neurons-n_exc izh_celltype = p.native_cell_type('izhikevich') if_celltype = p.IF_curr_exp celltype = if_celltype spike_source = p.native_cell_type('poisson_generator') inp_pop=p.Population(n_input_neurons*10,spike_source,{'rate':input_rates}) exc_cells = p.Population(n_exc, celltype, label="Excitatory_Cells") inh_cells = p.Population(n_inh, celltype, label="Inhibitory_Cells") # initialize with a uniform random distributin # use seeding for reproducability rngseed = 98766987 parallel_safe = True rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe) unifDistr = RandomDistribution('uniform', (-70,-65), rng=rng) inh_cells.initialize('V_m',unifDistr) exc_cells.initialize('V_m',unifDistr) readout_neurons = p.Population(2, celltype, label="readout_neuron") inp_weight=3. inp_delay =1 inp_weight_distr = RandomDistribution('normal', [inp_weight, 1e-3], rng=rng) # connect each input neuron to 30% of the reservoir neurons inp_conn = p.FixedProbabilityConnector(p_connect=0.3,weights =inp_weight_distr, delays=inp_delay) connections = {} connections['inp2e'] = p.Projection(inp_pop, exc_cells, inp_conn) connections['inp2i'] = p.Projection(inp_pop, inh_cells, inp_conn) pconn = 0.01 # sparse connection probability # scale the weights w.r.t. the network to keep it stable w_exc = w_exc_b/np.sqrt(n_res) # nA w_inh = w_inh_b/np.sqrt(n_res) # nA delay_exc = 1 # defines how long (ms) the synapse takes for transmission delay_inh = 1 weight_distr_exc = RandomDistribution('normal', [w_exc, 1/n_res], rng=rng) weight_distr_inh = RandomDistribution('normal', [w_inh, 1/n_res], rng=rng) exc_conn = p.FixedProbabilityConnector(pconn, weights=weight_distr_exc, delays=delay_exc) inh_conn = p.FixedProbabilityConnector(pconn, weights=weight_distr_inh, delays=delay_inh) connections['e2e'] = p.Projection(exc_cells, exc_cells, exc_conn, target='excitatory') connections['e2i'] = p.Projection(exc_cells, inh_cells, exc_conn, target='excitatory') connections['i2e'] = p.Projection(inh_cells, exc_cells, inh_conn, target='inhibitory') connections['i2i'] = p.Projection(inh_cells, inh_cells, inh_conn, target='inhibitory') rout_conn_exc = p.AllToAllConnector(weights=rout_w_exc, delays=delay_exc) rout_conn_inh = p.AllToAllConnector(weights=rout_w_inh, delays=delay_exc) connections['e2rout'] = p.Projection(exc_cells, readout_neurons, rout_conn_exc, target='excitatory') connections['i2rout'] = p.Projection(inh_cells, readout_neurons, rout_conn_inh, target='inhibitory') readout_neurons.record() exc_cells.record() inh_cells.record() inp_pop.record() p.run(20) r_spikes = readout_neurons.getSpikes() exc_spikes = exc_cells.getSpikes() inh_spikes = inh_cells.getSpikes() inp_spikes = inp_pop.getSpikes() rospy.loginfo('=====> shape of r_spikes %r', np.shape(r_spikes)) #==================================================================== # Compute Readout Spike Rates #==================================================================== alpha_rates = alpha_decoding(r_spikes,dt) mean_rates = mean_decoding(r_spikes,dt) #==================================================================== # Publish Readout Rates #==================================================================== # TODO: error handling if r_spikes is empty pub = rospy.Publisher('/alpha_readout_rates', Pop_List, queue_size=10) alpha_readout_rates = Pop_List alpha_readout_rates = alpha_rates pub.publish(alpha_readout_rates) pub = rospy.Publisher('/mean_readout_rates', Pop_List, queue_size=10) mean_readout_rates = Pop_List mean_readout_rates = mean_rates pub.publish(mean_readout_rates)
cellclass=neuron_model, cellparams=neuron_parameters_FS_cell) #V value initialization sim.initialize(Neurons_RS, v=-65.0, gsyn_exc=0, gsyn_inh=0) # v:mV, gsyn_exc:nS, gsyn_inh:nS sim.initialize(Neurons_FS, v=-65.0, gsyn_exc=0, gsyn_inh=0) ## RECURRENT CONNECTIONS #The two populations of neurons are randomly connected # (internally and mutually) with a connectivity probability of 5% # exc_exc exc_exc = sim.Projection(Neurons_RS, Neurons_RS, sim.FixedProbabilityConnector( 0.05, allow_self_connections=False), receptor_type='excitatory', synapse_type=sim.StaticSynapse(weight=0.001)) # exc_inh exc_inh = sim.Projection(Neurons_RS, Neurons_FS, sim.FixedProbabilityConnector( 0.05, allow_self_connections=False), receptor_type='excitatory', synapse_type=sim.StaticSynapse(weight=0.001)) # inh_exc inh_exc = sim.Projection(Neurons_FS, Neurons_RS, sim.FixedProbabilityConnector( 0.05, allow_self_connections=False), receptor_type='inhibitory',
###################### ###### Synapses ####### stat_syn_input = p.StaticSynapse(weight=dist_input, delay=1) stat_syn_exc = p.StaticSynapse(weight=dist_exc, delay=1) stat_syn_inh = p.StaticSynapse(weight=dist_inh, delay=1) #stat_syn_input = p.StaticSynapse(weight =50.0, delay=1) ###################### ###### Connections ####### exc_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng) inh_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng) inp_conn = p.FixedProbabilityConnector(0.5, rng=param.rng) rout_conn = p.AllToAllConnector() connections = {} connections['e2e'] = p.Projection(reservoir_exc, reservoir_exc, exc_conn, synapse_type=stat_syn_exc, receptor_type='excitatory') connections['e2i'] = p.Projection(reservoir_exc, reservoir_inh, exc_conn, synapse_type=stat_syn_exc, receptor_type='excitatory')
# setup simulation timestep = 0.5 num_threads = 4 sim.setup(timestep=timestep, min_delay=1.0, max_delay=1001.0, threads=num_threads) # ========================================================================= # # ------------------------create pyNN network------------------------------ # # ========================================================================= # # ====================================================================================================== # create connectors # ====================================================================================================== # connector_inp_hiddenP = sim.FixedProbabilityConnector(p_connect=Pconnect_intra) connector_hiddenPexc_hiddenPinh = sim.FixedProbabilityConnector(p_connect=Pconnect_intra) connector_hiddenPinh_hiddenPexc = sim.FixedProbabilityConnector(p_connect=Pconnect_intra) #connector_hiddenP_hiddenP = sim.FixedProbabilityConnector(p_connect=Pconnect_intra) # ====================================================================================================== # create populations # ====================================================================================================== N_input = 2 input_populations = [] for idx in range(N_input): input_populations.append(sim.Population(hiddenPexc_size, sim.IF_curr_exp, neuron_parameters)) hidden_populations = [ [] for x in range(N_res)] for idx in range(N_res):
import pyNN.nest as sim # can of course replace `neuron` with `nest`, `brian`, etc. import matplotlib.pyplot as plt import numpy as np sim.setup(timestep=0.01) p_in = sim.Population(10, sim.SpikeSourcePoisson(rate=10.0), label="input") p_out = sim.Population(10, sim.EIF_cond_exp_isfa_ista(), label="AdExp neurons") syn = sim.StaticSynapse(weight=0.05) random = sim.FixedProbabilityConnector(p_connect=0.5) connections = sim.Projection(p_in, p_out, random, syn, receptor_type='excitatory') p_in.record('spikes') p_out.record('spikes') # record spikes from all neurons p_out[0:2].record(['v', 'w', 'gsyn_exc' ]) # record other variables from first two neurons sim.run(500.0) spikes_in = p_in.get_data() print("spikes_in : ", type(spikes_in)) print("spikes_in.segments[0].spiketrains[0]", spikes_in.segments[0].spiketrains[0]) #print("spikes_in.segments[-1].spiketrains",spikes_in.segments[-1].spiketrains) spike_result = p_in.getSpikes(compatible_output=True)
# define stdp rules, parameters could be messed around with here. stdp = pynn.STDPMechanism( weight=0.02, # this is the initial value of the weight timing_dependence=pynn.SpikePairRule(tau_plus=20.0, tau_minus=20.0, A_plus=0.01, A_minus=0.012), weight_dependence=pynn.AdditiveWeightDependence(w_min=0, w_max=0.04)) synapse_to_use = stdp if args.stdp else pynn.StaticSynapse(weight=0.02) # connect inhibitory and excitatory sources to target. Could connect inhib to excit? if args.inhib_conn_type == 'ff': inhib_conn = pynn.Projection( inhib_source, target_pop, connector=pynn.FixedProbabilityConnector(0.75), synapse_type=synapse_to_use, receptor_type='inhibitory') elif args.inhib_conn_type == 'lat': inhib_conn = pynn.Projection( target_pop, target_pop, connector=pynn.FixedProbabilityConnector(0.75), synapse_type=synapse_to_use, receptor_type='inhibitory') else: print(dt.datetime.now().isoformat() + ' ERROR: ' + 'Unrecognised inhibatory connection type!') excit_conn = pynn.Projection( excit_source, target_pop,