Modifying connectivity densities at runtime

[russelljjarvis]

@pabloabur

Would the approach described below be different if instead of adjusting the LIF cell parameters, instead if network connection density parameters where changed, but population cell count was constant.

Make tunable variables for connection densities and cell counts:

• Redefine “tunable” versions of your models (this is based on https://github.com/genn-team/genn/blob/master/include/genn/genn/neuronModels.h#L212-L248) with the parameters you want to tune replaced with “extra global parameters” which can be set at runtime:

lif_tunable_vthresh_model = create_custom_neuron_class(
    " lif_tunable_vthresh ",
    param_names=["C", "TauM", "Vrest", "Vreset", "TauRefrac"],
    var_name_types=[("V", "scalar"), ("RefracTime", "scalar")],
    derived_params=[("ExpTC", create_dpf_class(lambda pars, dt: np.exp(-dt / pars[1]))()),
                    ("Rmembrane", create_dpf_class(lambda pars, dt: pars[1] / pars[0])())],
   extra_global_params=[(“Vthresh”, “scalar*”)],
   sim_code=
        """
        if ($(RefracTime) <= 0.0) {
            const scalar alpha = ($(Isyn) * $(Rmembrane)) + $(Vrest);
            $(V) = alpha - ($(ExpTC) * (alpha - $(V)));
        }
        else {
            $(RefracTime) -= DT;
        }
        """,
    threshold_condition_code=
        """
        $(RefracTime) <= 0.0 && $(V) >= $(Vthresh)
        """,
    reset_code=
        """
        $(V) = $(Vreset);
        $(RefracTime) = $(TauRefrac);
        """,
    is_auto_refractory_required=False)

Then, once you add your population you can initialise your extra global parameter like:

neuron_pop = model.add_neuron_population(pop_name, pop_size, "LIF", lif_params, lif_init)

neuron_pop. set_extra_global_param("Vthresh", [-20.0])

And then change it freely at runtime with

Neuron_vthresh_view = neuron_pop.extra_global_params["Vthresh"].view[:] = -20.0
Neuron_pop.push_extra_global_param_to_device("Vthresh")

This approach works for almost everything including variable initialisation (although there you need to call model.reinitialize() to resample distributions). Hope that makes sense, most of this is described in the manual at https://genn-team.github.io/genn/documentation/4/html/de/ded/sectNeuronModels.html#neuron_extra_global_param and https://genn-team.github.io/genn/documentation/4/html/d0/da6/UserGuide.html#extraGlobalParamSim (click the Python button at the top)

[neworderofjamie]

That is an interesting question! In most cases, you could indeed apply a very similar approach and create a modified version of, for example the FixedProbability connectivity initialisation snippet, with the parameters replaced by an extra global parameter. The only slightly tricky part is that you will also need an actual parameter specifying the densest configuration to allow the SET_CALC_MAX_ROW_LENGTH_FUNC function to allocate enough memory. With all this in place, you should be able to change connection density by setting the appropriate extra global parameter and calling model.reinitialize() to rebuild the model.

However, the Potjans microcircuit (and multi-area model) use a "fixed total number" connection pattern which, as described in https://www.frontiersin.org/article/10.3389/fnins.2018.00941/full, requires some CPU computation before it can be generated on the GPU (this bit of code). This is already done through an extra global parameter array called preCalcRowLength but, this isn't normally accessible to PyGeNN. However, you can hack around that by doing the following on each synapse group in your model:

sg.connectivity_extra_global_params["preCalcRowLength"].view =\
    sg._assign_ext_ptr_array("preCalcRowLength",
    sg.src.size, 
    "uint16_t")

Then, when you want to update the connectivity density you need to build a new preCalcRowLength array for each synapse group from the total number of connections like:

from scipy.stats import binom

def build_row_lengths(sg, num_connections):
    remaining_connections = num_connections
    matrix_size = sg.src.size * sg.trg.size
   
    row_lengths = sg.connectivity_extra_global_params["preCalcRowLength"].view 
    for i in range(sg.src.size- 1):
        probability = float(sg.trg.size) / float(matrix_size)

        # Sample row length;
        row_lengths[i] = binom.rvs(remaining_connections, probability)

        # Update counters
        remaining_connections -= row_lengths[i]
        matrix_size -= sg.trg.size

    # Insert remaining connections into last row
    row_lengths[num_pre - 1] = remaining_connections

Finally, you would upload the updated row lengths to the GPU and reininitialize the model:

sg._push_extra_global_param_to_device("preCalcRowLength", sg.connectivity_extra_global_params)
model.reinitialize()