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)
