def compile(self, mlg_model, name): pool_kh, pool_kw = self.pool_size pool_sh, pool_sw = self.pool_strides pool_ih, pool_iw, pool_ic = self.source().shape pool_oh, pool_ow, pool_oc = self.target().shape conn_init = init_connectivity(avepool2d_init, { 'pool_kh': pool_kh, 'pool_kw': pool_kw, 'pool_sh': pool_sh, 'pool_sw': pool_sw, 'pool_ih': pool_ih, 'pool_iw': pool_iw, 'pool_ic': pool_ic, 'pool_oh': pool_oh, 'pool_ow': pool_ow, 'pool_oc': pool_oc}) if self.connectivity_type is ConnectivityType.SPARSE: conn = 'SPARSE_GLOBALG' elif self.connectivity_type is ConnectivityType.PROCEDURAL: conn = 'PROCEDURAL_GLOBALG' elif self.connectivity_type is ConnectivityType.TOEPLITZ: print("WARNING: falling back to procedural connectivity for AvePool2DSynapses") conn = 'PROCEDURAL_GLOBALG' wu_model = signed_static_pulse if self.source().neurons.signed_spikes else 'StaticPulse' wu_var = {'g': 1.0 / (pool_kh * pool_kw)} super(AvePool2DSynapses, self).compile(mlg_model, name, conn, wu_model, {}, wu_var, {}, {}, 'DeltaCurr', {}, {}, conn_init, {})
def _init_connectivity(self): if self.connectivity_init_possible: return init_connectivity(self._builtin_name, self._conn_init_params) raise Exception( 'Requested on-device sparse connectivity initializer for ' 'a connector which is not (yet) supported')
def compile(self, mlg_model, name): conn_init = init_connectivity('OneToOne', {}) conn = ('PROCEDURAL_GLOBALG' if self.connectivity_type == ConnectivityType.PROCEDURAL else 'SPARSE_GLOBALG') wu_model = signed_static_pulse if self.source( ).neurons.signed_spikes else 'StaticPulse' wu_var = {'g': 1.0} super(IdentitySynapses, self).compile(mlg_model, name, conn, wu_model, {}, wu_var, {}, {}, 'DeltaCurr', {}, {}, conn_init, {})
def compile(self, mlg_model, name): conv_kh, conv_kw = self.conv_size conv_sh, conv_sw = self.conv_strides conv_ih, conv_iw, conv_ic = self.source().shape conv_oh, conv_ow, conv_oc = self.target().shape if self.conv_padding is PadMode.VALID: conv_padh = 0 conv_padw = 0 elif self.conv_padding is PadMode.SAME: conv_padh = _get_conv_same_padding(conv_ih, conv_kh, conv_sh) conv_padw = _get_conv_same_padding(conv_iw, conv_kw, conv_sw) wu_model = signed_static_pulse if self.source( ).neurons.signed_spikes else 'StaticPulse' conn_init = init_connectivity( convtranspose2d_init, { 'conv_kh': conv_kh, 'conv_kw': conv_kw, 'conv_sh': conv_sh, 'conv_sw': conv_sw, 'conv_padh': conv_padh, 'conv_padw': conv_padw, 'conv_ih': conv_ih, 'conv_iw': conv_iw, 'conv_ic': conv_ic, 'conv_oh': conv_oh, 'conv_ow': conv_ow, 'conv_oc': conv_oc }) if self.connectivity_type is ConnectivityType.SPARSE: conn = 'SPARSE_INDIVIDUALG' wu_var = {'g': init_var('Kernel', {})} wu_var_egp = {'g': {'kernel': self.weights.flatten()}} elif self.connectivity_type is ConnectivityType.PROCEDURAL: conn = 'PROCEDURAL_KERNELG' wu_var = {'g': self.weights.flatten()} wu_var_egp = {} elif self.connectivity_type is ConnectivityType.TOEPLITZ: print('WARNING: falling back to procedural connectivity ' 'for ConvTranspose2DSynapses') conn = 'PROCEDURAL_KERNELG' wu_var = {'g': self.weights.flatten()} wu_var_egp = {} super(ConvTranspose2DSynapses, self).compile(mlg_model, name, conn, wu_model, {}, wu_var, {}, {}, 'DeltaCurr', {}, {}, conn_init, wu_var_egp)
def build_model(name, params, reward_timesteps): model = genn_model.GeNNModel("float", name) model.dT = params["timestep_ms"] model._model.set_merge_postsynaptic_models(True) model._model.set_default_narrow_sparse_ind_enabled(True) if "seed" in params: model._model.set_seed(params["seed"]) model.timing_enabled = params["measure_timing"] # Excitatory model parameters exc_params = {"a": 0.02, "b": 0.2, "c": -65.0, "d": 8.0, "tauD": params["tau_d"], "dStrength": params["dopamine_strength"]} # Excitatory initial state exc_init = {"V": -65.0, "U": -13.0, "D": 0.0} # Inhibitory model parameters inh_params = {"a": 0.1, "b": 0.2, "c": -65.0, "d": 2.0} # Inhibitory initial state inh_init = {"V": -65.0, "U": -13.0} # Static inhibitory synapse initial state inh_syn_init = {"g": params["inh_weight"]} # STDP parameters stdp_params = {"tauPlus": 20.0, "tauMinus": 20.0, "tauC": 1000.0, "tauD": params["tau_d"], "aPlus": 0.1, "aMinus": 0.15, "wMin": 0.0, "wMax": params["max_exc_weight"]} # STDP initial state stdp_init = {"g": params["init_exc_weight"], "c": 0.0} # Fixed probability connector parameters fixed_prob_params = {"prob": params["probability_connection"]} # Create excitatory and inhibitory neuron populations e_pop = model.add_neuron_population("E", params["num_excitatory"], izhikevich_dopamine_model, exc_params, exc_init) i_pop = model.add_neuron_population("I", params["num_inhibitory"], "Izhikevich", inh_params, inh_init) # Turn on zero-copy for spikes if required if params["use_zero_copy"]: e_pop.pop.set_spike_location(genn_wrapper.VarLocation_HOST_DEVICE_ZERO_COPY) i_pop.pop.set_spike_location(genn_wrapper.VarLocation_HOST_DEVICE_ZERO_COPY) # Set dopamine timestep bitmask e_pop.set_extra_global_param("rewardTimesteps", reward_timesteps) # Enable spike recording e_pop.spike_recording_enabled = params["use_genn_recording"] i_pop.spike_recording_enabled = params["use_genn_recording"] # Add synapse population e_e_pop = model.add_synapse_population("EE", "SPARSE_INDIVIDUALG", genn_wrapper.NO_DELAY, "E", "E", izhikevich_stdp_model, stdp_params, stdp_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbability", fixed_prob_params)) e_i_pop = model.add_synapse_population("EI", "SPARSE_INDIVIDUALG", genn_wrapper.NO_DELAY, "E", "I", izhikevich_stdp_model, stdp_params, stdp_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbability", fixed_prob_params)) model.add_synapse_population("II", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, "I", "I", "StaticPulse", {}, inh_syn_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbability", fixed_prob_params)) model.add_synapse_population("IE", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, "I", "E", "StaticPulse", {}, inh_syn_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbability", fixed_prob_params)) # Return model and populations return model, e_pop, i_pop, e_e_pop, e_i_pop
def connect(simulation, target_area, source_area): """ Connect two areas with each other. Parameters ---------- simulation : Simulation instance Simulation simulating the network containing the two areas. target_area : Area instance Target area of the projection source_area : Area instance Source area of the projection """ num_sub_rows = (simulation.params['num_threads_per_spike'] if simulation.params['procedural_connectivity'] else 1) matrix_type = "PROCEDURAL_PROCEDURALG" if simulation.params[ 'procedural_connectivity'] else "SPARSE_INDIVIDUALG" network = simulation.network synapses = extract_area_dict(network.synapses, network.structure, target_area.name, source_area.name) W = extract_area_dict(network.W, network.structure, target_area.name, source_area.name) W_sd = extract_area_dict(network.W_sd, network.structure, target_area.name, source_area.name) for target in target_area.populations: for source in source_area.populations: num_connections = int(synapses[target][source]) conn_spec = {"total": num_connections} syn_weight = { "mean": W[target][source] / 1000.0, "sd": W_sd[target][source] / 1000.0 } exp_curr_params = {} if target_area == source_area: max_delay = simulation.max_inter_area_delay if 'E' in source: mean_delay = network.params['delay_params']['delay_e'] elif 'I' in source: mean_delay = network.params['delay_params']['delay_i'] else: max_delay = simulation.max_intra_area_delay v = network.params['delay_params']['interarea_speed'] s = network.distances[target_area.name][source_area.name] mean_delay = s / v if 'E' in source: exp_curr_params.update({ 'tau': network.params['neuron_params']['single_neuron_dict'] ['tau_syn_ex'] }) syn_weight.update({ 'min': 0., 'max': float(np.finfo(np.float32).max) }) else: exp_curr_params.update({ 'tau': network.params['neuron_params']['single_neuron_dict'] ['tau_syn_in'] }) syn_weight.update({ 'min': float(-np.finfo(np.float32).max), 'max': 0. }) delay_sd = mean_delay * network.params['delay_params']['delay_rel'] syn_delay = { 'min': simulation.params['dt'], 'max': max_delay, 'mean': mean_delay, 'sd': delay_sd } syn_spec = { 'g': genn_model.init_var("NormalClipped", syn_weight), 'd': genn_model.init_var("NormalClippedDelay", syn_delay) } # Add synapse population source_genn_pop = source_area.genn_pops[source] target_genn_pop = target_area.genn_pops[target] syn_pop = simulation.model.add_synapse_population( source_genn_pop.name + "_" + target_genn_pop.name, matrix_type, genn_wrapper.NO_DELAY, source_genn_pop, target_genn_pop, "StaticPulseDendriticDelay", {}, syn_spec, {}, {}, "ExpCurr", exp_curr_params, {}, genn_model.init_connectivity("FixedNumberTotalWithReplacement", conn_spec)) # Add size of this allocation to total simulation.extra_global_param_bytes += source_genn_pop.size * num_sub_rows * 2 # Set max dendritic delay and span type syn_pop.pop.set_max_dendritic_delay_timesteps( int(round(max_delay / simulation.params['dt']))) if simulation.params['procedural_connectivity']: syn_pop.pop.set_span_type( genn_wrapper.SynapseGroup.SpanType_PRESYNAPTIC) syn_pop.pop.set_num_threads_per_spike( simulation.params['num_threads_per_spike'])
s_ini = {"g": -0.2} ps_p = { "tau": 1.0, # Decay time constant [ms] "E": -80.0 } # Reversal potential [mV] stim_ini = {"startSpike": [0], "endSpike": [1]} pop1 = model.add_neuron_population("Pop1", 10, "TraubMiles", p, ini) stim = model.add_neuron_population("Stim", 1, "SpikeSourceArray", {}, stim_ini) model.add_synapse_population("Pop1self", "SPARSE_GLOBALG", 10, pop1, pop1, "StaticPulse", {}, s_ini, {}, {}, "ExpCond", ps_p, {}, init_connectivity(ring_model, {})) model.add_synapse_population("StimPop1", "SPARSE_GLOBALG", NO_DELAY, stim, pop1, "StaticPulse", {}, s_ini, {}, {}, "ExpCond", ps_p, {}, init_connectivity("OneToOne", {})) stim.set_extra_global_param("spikeTimes", [0.0]) model.build() model.load() v = np.empty((2000, 10)) v_view = pop1.vars["V"].view while model.t < 200.0: model.step_time() pop1.pull_var_from_device("V")
lif_init) pre_stim_pop = model.add_neuron_population("PreStim", NUM_NEURONS, "SpikeSourceArray", {}, stim_init) post_stim_pop = model.add_neuron_population("PostStim", NUM_NEURONS, "SpikeSourceArray", {}, stim_init) # Set spike source spike times pre_stim_pop.set_extra_global_param("spikeTimes", pre_stim_spike_times) post_stim_pop.set_extra_global_param("spikeTimes", post_stim_spike_times) # Add STDP connection between presynaptic spike source and neurons # Uses build in one-to-one connectivity and initialises all weights to 0.5 (midway between wMin and wMax) pre_stim_to_pop = model.add_synapse_population( "PreStimToPop", "SPARSE_INDIVIDUALG", genn_wrapper.NO_DELAY, pre_stim_pop, neuron_pop, hebbian_stdp_model, stdp_params, {"g": 0.5}, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("OneToOne", {})) # Add static connection between postsynaptic spike source and neurons # Uses built in one-to-one connectivity and initialises all weights to large value to cause immediate spikes model.add_synapse_population("PostStimToPop", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, post_stim_pop, neuron_pop, "StaticPulse", {}, {"g": 8.0}, {}, {}, "ExpCurr", {"tau": 5.0}, {}, genn_model.init_connectivity("OneToOne", {})) # Build and load model model.build() model.load() # Simulate model while model.t < 60200.0:
lif_init = {"V": -60.0, "RefracTime": 0.0} pn = model.add_neuron_population("pn", NUM_PN, "LIF", PN_PARAMS, lif_init) kc = model.add_neuron_population("kc", NUM_KC, "LIF", KC_PARAMS, lif_init) ggn = model.add_neuron_population("ggn", 1, "LIF", GGN_PARAMS, lif_init) mbon = model.add_neuron_population("mbon", NUM_MBON, "LIF", MBON_PARAMS, lif_init) # Create current source to deliver input to network pn_input = model.add_current_source("pn_input", cs_model, "pn", {}, {"magnitude": 0.0}) # Create synapse populations model.add_synapse_population( "pn_kc", "SPARSE_GLOBALG", NO_DELAY, pn, kc, "StaticPulse", {}, {"g": PN_KC_WEIGHT}, {}, {}, "ExpCurr", {"tau": PN_KC_TAU_SYN}, {}, init_connectivity("FixedProbabilityNoAutapse", {"prob": PN_KC_SPARSITY})) model.add_synapse_population("kc_ggn", "DENSE_GLOBALG", NO_DELAY, kc, ggn, "StaticPulse", {}, {"g": KC_GGN_WEIGHT}, {}, {}, "ExpCurr", {"tau": KC_GGN_TAU_SYN}, {}) model.add_synapse_population("ggn_kc", "DENSE_GLOBALG", NO_DELAY, ggn, kc, graded_synapse_model, GGN_KC_PARAMS, {"g": GGN_KC_WEIGHT}, {}, {}, "ExpCurr", {"tau": GGN_KC_TAU_SYN}, {}) kc_mbon = model.add_synapse_population( "kc_mbon", "DENSE_INDIVIDUALG", NO_DELAY, kc, mbon, symmetric_stdp, KC_MBON_PARAMS, {"g": init_var("Uniform", KC_MBON_WEIGHT)}, {}, {}, "ExpCurr", {"tau": KC_MBON_TAU_SYN}, {})
def compile(self, mlg_model, name): conv_kh, conv_kw = self.conv_size conv_sh, conv_sw = self.conv_strides conv_ih, conv_iw, conv_ic = self.source().shape conv_oh, conv_ow, conv_oc = self.target().shape if self.conv_padding == PadMode.VALID: conv_padh = 0 conv_padw = 0 elif self.conv_padding == PadMode.SAME: conv_padh = _get_conv_same_padding(conv_ih, conv_kh, conv_sh) conv_padw = _get_conv_same_padding(conv_iw, conv_kw, conv_sw) wu_model = signed_static_pulse if self.source( ).neurons.signed_spikes else 'StaticPulse' if (self.connectivity_type == ConnectivityType.TOEPLITZ and conv_sh == 1 and conv_sw == 1): conn_init = init_toeplitz_connectivity( 'Conv2D', { 'conv_kh': conv_kh, 'conv_kw': conv_kw, 'conv_ih': conv_ih, 'conv_iw': conv_iw, 'conv_ic': conv_ic, 'conv_oh': conv_oh, 'conv_ow': conv_ow, 'conv_oc': conv_oc }) conn = 'TOEPLITZ_KERNELG' wu_var = {'g': self.weights.flatten()} wu_var_egp = {} else: conn_init = init_connectivity( 'Conv2D', { 'conv_kh': conv_kh, 'conv_kw': conv_kw, 'conv_sh': conv_sh, 'conv_sw': conv_sw, 'conv_padh': conv_padh, 'conv_padw': conv_padw, 'conv_ih': conv_ih, 'conv_iw': conv_iw, 'conv_ic': conv_ic, 'conv_oh': conv_oh, 'conv_ow': conv_ow, 'conv_oc': conv_oc }) if self.connectivity_type == ConnectivityType.SPARSE: conn = 'SPARSE_INDIVIDUALG' wu_var = {'g': init_var('Kernel', {})} wu_var_egp = {'g': {'kernel': self.weights.flatten()}} else: if self.connectivity_type == ConnectivityType.TOEPLITZ: print( "WARNING: falling back to procedural connectivity " "for Conv2D connectivity with unsupported parameters") conn = 'PROCEDURAL_KERNELG' wu_var = {'g': self.weights.flatten()} wu_var_egp = {} super(Conv2DSynapses, self).compile(mlg_model, name, conn, wu_model, {}, wu_var, {}, {}, 'DeltaCurr', {}, {}, conn_init, wu_var_egp)
def _generate_init_snippet(self): def _max_col_len(num_pre, num_post, pars): max_d = (2.0 * pars[1] + 1.0) max_conns = 1.0 if pars[2] > 1: max_conns *= min(max_d / pars[8], pars[2]) if pars[3] > 1: max_conns *= min(max_d / pars[9], pars[3]) if pars[4] > 1: max_conns *= min(max_d / pars[10], pars[4]) if pars[0] > 0.95: return int(max_conns) else: return int(binom.ppf(0.9999 ** (1.0 / num_post), n=max_conns, p=pars[0])) def _max_row_len(num_pre, num_post, pars): max_d = (2.0 * pars[1] + 1.0) max_conns = 1.0 if pars[11] > 1: max_conns *= min(max_d / pars[17], pars[11]) if pars[12] > 1: max_conns *= min(max_d / pars[18], pars[12]) if pars[13] > 1: max_conns *= min(max_d / pars[19], pars[13]) if pars[0] > 0.95: return int(max_conns) else: return int(binom.ppf(0.9999 ** (1.0 / num_pre), n=max_conns, p=pars[0])) _param_space = self._conn_init_params shp = self.shapes pre_per_row = int(shp['pre_nx'] * shp['pre_nz']) post_per_row = int(shp['post_nx'] * shp['post_nz']) delta_row = int( ((self.max_dist / shp['post_dy']) + 2) * post_per_row ) n_post = shp['post_nx'] * shp['post_ny'] * shp['post_nz'] names = [ "prob", "max_dist", "pre_nx", "pre_ny", "pre_nz", "pre_x0", "pre_y0", "pre_z0", "pre_dx", "pre_dy", "pre_dz", "post_nx", "post_ny", "post_nz", "post_x0", "post_y0", "post_z0", "post_dx", "post_dy", "post_dz" ] state_vars = [ # ("perRow", "int", per_row), # ("deltaRow", "int", delta_row), ("preRow", "int", "($(id_pre) / {}) * $(pre_dy) + $(pre_y0)".format(pre_per_row)), ("prevJ", "int", "fmax(-1.0f,\n" " (float)( ((preRow - $(post_y0)) / $(post_dy)) * {} - {} - 1 )\n" ")".format(post_per_row, delta_row)), ("endJ", "int", "fmin({}f, \n" " (float)( ((preRow - $(post_y0)) / $(post_dy)) * {} + {} + 1 )\n" ")".format(float(n_post), post_per_row, delta_row)), ] derived = [ ("probLogRecip", genn_model.create_dpf_class( lambda pars, dt: (1.0 / np.log(1.0 - pars[0])))() ) ] _code = """ #ifndef toCoords #define toCoords(idx, nx, ny, nz, x, y, z) { \\ int a = (int)(nx * nz); \\ int inz = (int)nz; \\ y = (float)(idx / a); \\ x = (float)((idx - ((int)y * a)) / inz); \\ z = (float)((idx - ((int)y * a)) % inz); \\ } #endif #ifndef inDist #define inDist(pre, pre_nx, pre_ny, pre_nz, \\ pre_dx, pre_dy, pre_dz, pre_x0, pre_y0, pre_z0, \\ post, post_nx, post_ny, post_nz, \\ post_dx, post_dy, post_dz, post_x0, post_y0, post_z0, \\ max_dist, output) { \\ float pre_x, pre_y, pre_z, post_x, post_y, post_z; \\ toCoords(pre, pre_nx, pre_ny, pre_nz, pre_x, pre_y, pre_z); \\ toCoords(post, post_nx, post_ny, post_nz, post_x, post_y, post_z); \\ pre_x = pre_x * pre_dx + pre_x0; \\ pre_y = pre_y * pre_dy + pre_y0; \\ pre_z = pre_z * pre_dz + pre_z0; \\ post_x = post_x * post_dx + post_x0; \\ post_y = post_y * post_dy + post_y0; \\ post_z = post_z * post_dz + post_z0; \\ float dx = post_x - pre_x, \\ dy = post_y - pre_y, \\ dz = post_z - pre_z; \\ output = ( sqrt( (dx * dx) + (dy * dy) + (dz * dz) ) <= max_dist ); \\ } #endif const scalar u = $(gennrand_uniform); prevJ += (1 + (int)(log(u) * $(probLogRecip))); if(prevJ < endJ) { int out = 0; inDist($(id_pre), $(pre_nx), $(pre_ny), $(pre_nz), $(pre_dx), $(pre_dy), $(pre_dz), $(pre_x0), $(pre_y0), $(pre_z0), prevJ, $(post_nx), $(post_ny), $(post_nz), $(post_dx), $(post_dy), $(post_dz), $(post_x0), $(post_y0), $(post_z0), $(max_dist), out); if(out){ $(addSynapse, prevJ + $(id_post_begin)); } } else { $(endRow); } """ _snip = genn_model.create_custom_sparse_connect_init_snippet_class( "max_distance_fixed_probability", param_names=names, row_build_state_vars=state_vars, derived_params=derived, calc_max_row_len_func=genn_model.create_cmlf_class(_max_row_len)(), calc_max_col_len_func=genn_model.create_cmlf_class(_max_col_len)(), row_build_code=_code) return genn_model.init_connectivity(_snip, _param_space)
stdp_init, stdp_pre_init, {}, "ExpCond", { "tau": tau_ge, "E": e_exc }, {}) syn_ei_pop = model.add_synapse_population( "syn_ei_pop", "SPARSE_INDIVIDUALG", genn_wrapper.NO_DELAY, lif_e_pop, lif_i_pop, "StaticPulse", {}, {"g": genn_model.init_var("Uniform", { "min": 0.0, "max": g_max })}, {}, {}, "ExpCond", { "tau": tau_gi, "E": e_inh }, {}, genn_model.init_connectivity("OneToOne", {})) syn_ie_pop = model.add_synapse_population( "syn_ie_pop", "DENSE_INDIVIDUALG", genn_wrapper.NO_DELAY, lif_i_pop, lif_e_pop, "StaticPulse", {}, {"g": genn_model.init_var(lateral_inhibition, {"weight": 0.1})}, {}, {}, "ExpCond", { "tau": tau_ge, "E": e_exc }, {}) # ******************************************************************************** # Building and Simulation # ******************************************************************************** model.dT = timestep print("Building Model")
exc_syn_init = {"g": 0.05} inh_syn_init = {"g": -0.25} fixed_prob = {"prob": 0.1} exc = model.add_neuron_population("Exc", 8000, "Izhikevich", izk_params, izk_init) inh = model.add_neuron_population("Inh", 2000, "Izhikevich", izk_params, izk_init) model.add_current_source("ExcStim", "DC", "Exc", stim_params, {}) model.add_current_source("InhStim", "DC", "Inh", stim_params, {}) model.add_synapse_population("Exc_Exc", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, exc, exc, "StaticPulse", {}, exc_syn_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbabilityNoAutapse", fixed_prob)) model.add_synapse_population("Exc_Inh", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, exc, inh, "StaticPulse", {}, exc_syn_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbability", fixed_prob)) model.add_synapse_population("Inh_Inh", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, inh, inh, "StaticPulse", {}, inh_syn_init, {}, {}, "DeltaCurr", {}, {}, genn_model.init_connectivity("FixedProbabilityNoAutapse", fixed_prob)) model.add_synapse_population("Inh_Exc", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, inh, exc,
# Create current source to deliver input to first layers of neurons current_input = model.add_current_source("current_input", cs_model, "neuron0", {}, {"magnitude": 0.0}) # Create subsequent neuron layer for i, w in enumerate(weights): neuron_layers.append( model.add_neuron_population("neuron%u" % (i + 1), w.shape[1], "RulkovMap", rm_params, rm_init)) # Create synaptic connections between layers model.add_synapse_population("synapse%u" % 0, "DENSE_INDIVIDUALG", NO_DELAY, neuron_layers[0], neuron_layers[1], "StaticPulse", {}, {"g": weights[0].flatten()}, {}, {}, "DeltaCurr", {}, {}) model.add_synapse_population( "synapse%u" % 1, "DENSE_INDIVIDUALG", DELAY, neuron_layers[1], neuron_layers[2], stdp, {G_MAX, G_MIN}, {"g": init_var("Uniform", INIT_WEIGHTS)}, {}, {}, cb_synapse, ex_params, {"V": 50.0}, init_connectivity("FixedProbabilityNoAutapse", fixed_prob)) model.add_synapse_population( "synapse%u" % 2, "DENSE_INDIVIDUALG", DELAY, neuron_layers[2], neuron_layers[2], "StaticPulse", {}, {"g": init_var(lateral_inhibition, {"g": 0.025})}, {}, {}, "DeltaCurr", {}, init_connectivity("FixedProbabilityNoAutapse", fixed_prob)) # Build and load our model model.build() model.load()
# Alpha curr postsynaptic mode parameters and initial state alpha_curr_params = {"tau": TAU_SYN} alpha_curr_init = {"x": 0.0} # Weight update model initial state excitatory_synapse_init = {"g": SYNAPTIC_WEIGHT_PA / 1000.0} inhibitory_synapse_init = {"g": -5.0 * SYNAPTIC_WEIGHT_PA / 1000.0} if STATIC_SYNAPSES: # Add synapse population exc_exc_pop = model.add_synapse_population( "ExcExc", "SPARSE_GLOBALG_INDIVIDUAL_PSM", DELAY_TIMESTEPS - 1, "Exc", "Exc", "StaticPulse", {}, excitatory_synapse_init, {}, {}, alpha_curr_model, alpha_curr_params, alpha_curr_init, genn_model.init_connectivity("FixedNumberPreWithReplacement", {"colLength": NUM_INCOMING_EXCITATORY})) else: # STDP model parameters stdp_synapse_params = { "tauPlus": 15.0, "tauMinus": 30.0, "lambda": 0.1 / 1000.0, "alpha": 0.0513, "mu": 0.4, "denDelay": DELAY_MS } stdp_synapse_pre_init = {"preTrace": 0.0} stdp_synapse_post_init = {"postTrace": 0.0} # Add synapse population exc_exc_pop = model.add_synapse_population(
static_synapse_init = { "g": genn_model.init_var("NormalClipped", w_dist), "d": genn_model.init_var("NormalClippedDelay", d_dist) } # Add synapse population syn_pop = model.add_synapse_population( synapse_name, matrix_type, genn_wrapper.NO_DELAY, neuron_populations[src_name], neuron_populations[trg_name], "StaticPulseDendriticDelay", {}, static_synapse_init, {}, {}, "ExpCurr", exp_curr_params, {}, genn_model.init_connectivity( "FixedNumberTotalWithReplacement", connect_params)) # Set max dendritic delay and span type syn_pop.pop.set_max_dendritic_delay_timesteps( max_dendritic_delay_slots) if PROCEDURAL_CONNECTIVITY: syn_pop.pop.set_span_type( genn_wrapper.SynapseGroup.SpanType_PRESYNAPTIC) syn_pop.pop.set_num_threads_per_spike( NUM_THREADS_PER_SPIKE) # Inhibitory else: # Build distribution for weight parameters # **HACK** np.float32 doesn't seem to automatically cast
# Turn on spike recording pn.spike_recording_enabled = True kc.spike_recording_enabled = True mbon.spike_recording_enabled = True # Create current sources to deliver input and supervision to network pn_input = model.add_current_source("pn_input", cs_model, pn , {}, {"magnitude": 0.0}) mbon_input = model.add_current_source("mbon_input", cs_model, mbon , {}, {"magnitude": 0.0}) # Create synapse populations pn_kc = model.add_synapse_population("pn_kc", "SPARSE_GLOBALG", genn_wrapper.NO_DELAY, pn, kc, "StaticPulse", {}, {"g": PN_KC_WEIGHT}, {}, {}, "ExpCurr", {"tau": PN_KC_TAU_SYN}, {}, genn_model.init_connectivity("FixedNumberPreWithReplacement", {"colLength": PN_KC_COL_LENGTH})) if TRAIN: kc_mbon = model.add_synapse_population("kc_mbon", "DENSE_INDIVIDUALG", genn_wrapper.NO_DELAY, kc, mbon, symmetric_stdp, KC_MBON_PARAMS, {"g": np.ones(NUM_KC * NUM_MBON) * KC_MBON_WEIGHT}, {}, {}, "ExpCurr", {"tau": KC_MBON_TAU_SYN}, {}) else: kc_mbon = model.add_synapse_population("kc_mbon", "DENSE_INDIVIDUALG", genn_wrapper.NO_DELAY, kc, mbon, "StaticPulse", {}, {"g": np.load("kc_mbon_g.npy").flatten()}, {}, {}, "ExpCurr", {"tau": KC_MBON_TAU_SYN}, {}) # Build model and load it model.build() model.load(num_recording_timesteps=PRESENT_TIMESTEPS)